fs/f2fs/super.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * fs/f2fs/super.c
   4  *
   5  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   6  *             http://www.samsung.com/
   7  */
   8 #include <linux/module.h>
   9 #include <linux/init.h>
  10 #include <linux/fs.h>
  11 #include <linux/fs_context.h>
  12 #include <linux/sched/mm.h>
  13 #include <linux/statfs.h>
  14 #include <linux/kthread.h>
  15 #include <linux/parser.h>
  16 #include <linux/mount.h>
  17 #include <linux/seq_file.h>
  18 #include <linux/proc_fs.h>
  19 #include <linux/random.h>
  20 #include <linux/exportfs.h>
  21 #include <linux/blkdev.h>
  22 #include <linux/quotaops.h>
  23 #include <linux/f2fs_fs.h>
  24 #include <linux/sysfs.h>
  25 #include <linux/quota.h>
  26 #include <linux/unicode.h>
  27 #include <linux/part_stat.h>
  28 #include <linux/zstd.h>
  29 #include <linux/lz4.h>
  30
  31 #include "f2fs.h"
  32 #include "node.h"
  33 #include "segment.h"
  34 #include "xattr.h"
  35 #include "gc.h"
  36 #include "iostat.h"
  37
  38 #define CREATE_TRACE_POINTS
  39 #include <trace/events/f2fs.h>
  40
  41 static struct kmem_cache *f2fs_inode_cachep;
  42
  43 #ifdef CONFIG_F2FS_FAULT_INJECTION
  44
  45 const char *f2fs_fault_name[FAULT_MAX] = {
  46         [FAULT_KMALLOC]                 = "kmalloc",
  47         [FAULT_KVMALLOC]                = "kvmalloc",
  48         [FAULT_PAGE_ALLOC]              = "page alloc",
  49         [FAULT_PAGE_GET]                = "page get",
  50         [FAULT_ALLOC_NID]               = "alloc nid",
  51         [FAULT_ORPHAN]                  = "orphan",
  52         [FAULT_BLOCK]                   = "no more block",
  53         [FAULT_DIR_DEPTH]               = "too big dir depth",
  54         [FAULT_EVICT_INODE]             = "evict_inode fail",
  55         [FAULT_TRUNCATE]                = "truncate fail",
  56         [FAULT_READ_IO]                 = "read IO error",
  57         [FAULT_CHECKPOINT]              = "checkpoint error",
  58         [FAULT_DISCARD]                 = "discard error",
  59         [FAULT_WRITE_IO]                = "write IO error",
  60         [FAULT_SLAB_ALLOC]              = "slab alloc",
  61         [FAULT_DQUOT_INIT]              = "dquot initialize",
  62         [FAULT_LOCK_OP]                 = "lock_op",
  63         [FAULT_BLKADDR_VALIDITY]        = "invalid blkaddr",
  64         [FAULT_BLKADDR_CONSISTENCE]     = "inconsistent blkaddr",
  65         [FAULT_NO_SEGMENT]              = "no free segment",
  66 };
  67
  68 int f2fs_build_fault_attr(struct f2fs_sb_info *sbi, unsigned long rate,
  69                                                         unsigned long type)
  70 {
  71         struct f2fs_fault_info *ffi = &F2FS_OPTION(sbi).fault_info;
  72
  73         if (rate) {
  74                 if (rate > INT_MAX)
  75                         return -EINVAL;
  76                 atomic_set(&ffi->inject_ops, 0);
  77                 ffi->inject_rate = (int)rate;
  78         }
  79
  80         if (type) {
  81                 if (type >= BIT(FAULT_MAX))
  82                         return -EINVAL;
  83                 ffi->inject_type = (unsigned int)type;
  84         }
  85
  86         if (!rate && !type)
  87                 memset(ffi, 0, sizeof(struct f2fs_fault_info));
  88         else
  89                 f2fs_info(sbi,
  90                         "build fault injection attr: rate: %lu, type: 0x%lx",
  91                                                                 rate, type);
  92         return 0;
  93 }
  94 #endif
  95
  96 /* f2fs-wide shrinker description */
  97 static struct shrinker *f2fs_shrinker_info;
  98
  99 static int __init f2fs_init_shrinker(void)
 100 {
 101         f2fs_shrinker_info = shrinker_alloc(0, "f2fs-shrinker");
 102         if (!f2fs_shrinker_info)
 103                 return -ENOMEM;
 104
 105         f2fs_shrinker_info->count_objects = f2fs_shrink_count;
 106         f2fs_shrinker_info->scan_objects = f2fs_shrink_scan;
 107
 108         shrinker_register(f2fs_shrinker_info);
 109
 110         return 0;
 111 }
 112
 113 static void f2fs_exit_shrinker(void)
 114 {
 115         shrinker_free(f2fs_shrinker_info);
 116 }
 117
 118 enum {
 119         Opt_gc_background,
 120         Opt_disable_roll_forward,
 121         Opt_norecovery,
 122         Opt_discard,
 123         Opt_nodiscard,
 124         Opt_noheap,
 125         Opt_heap,
 126         Opt_user_xattr,
 127         Opt_nouser_xattr,
 128         Opt_acl,
 129         Opt_noacl,
 130         Opt_active_logs,
 131         Opt_disable_ext_identify,
 132         Opt_inline_xattr,
 133         Opt_noinline_xattr,
 134         Opt_inline_xattr_size,
 135         Opt_inline_data,
 136         Opt_inline_dentry,
 137         Opt_noinline_dentry,
 138         Opt_flush_merge,
 139         Opt_noflush_merge,
 140         Opt_barrier,
 141         Opt_nobarrier,
 142         Opt_fastboot,
 143         Opt_extent_cache,
 144         Opt_noextent_cache,
 145         Opt_noinline_data,
 146         Opt_data_flush,
 147         Opt_reserve_root,
 148         Opt_resgid,
 149         Opt_resuid,
 150         Opt_mode,
 151         Opt_fault_injection,
 152         Opt_fault_type,
 153         Opt_quota,
 154         Opt_noquota,
 155         Opt_usrquota,
 156         Opt_grpquota,
 157         Opt_prjquota,
 158         Opt_usrjquota,
 159         Opt_grpjquota,
 160         Opt_prjjquota,
 161         Opt_offusrjquota,
 162         Opt_offgrpjquota,
 163         Opt_offprjjquota,
 164         Opt_jqfmt_vfsold,
 165         Opt_jqfmt_vfsv0,
 166         Opt_jqfmt_vfsv1,
 167         Opt_alloc,
 168         Opt_fsync,
 169         Opt_test_dummy_encryption,
 170         Opt_inlinecrypt,
 171         Opt_checkpoint_disable,
 172         Opt_checkpoint_disable_cap,
 173         Opt_checkpoint_disable_cap_perc,
 174         Opt_checkpoint_enable,
 175         Opt_checkpoint_merge,
 176         Opt_nocheckpoint_merge,
 177         Opt_compress_algorithm,
 178         Opt_compress_log_size,
 179         Opt_compress_extension,
 180         Opt_nocompress_extension,
 181         Opt_compress_chksum,
 182         Opt_compress_mode,
 183         Opt_compress_cache,
 184         Opt_atgc,
 185         Opt_gc_merge,
 186         Opt_nogc_merge,
 187         Opt_discard_unit,
 188         Opt_memory_mode,
 189         Opt_age_extent_cache,
 190         Opt_errors,
 191         Opt_err,
 192 };
 193
 194 static match_table_t f2fs_tokens = {
 195         {Opt_gc_background, "background_gc=%s"},
 196         {Opt_disable_roll_forward, "disable_roll_forward"},
 197         {Opt_norecovery, "norecovery"},
 198         {Opt_discard, "discard"},
 199         {Opt_nodiscard, "nodiscard"},
 200         {Opt_noheap, "no_heap"},
 201         {Opt_heap, "heap"},
 202         {Opt_user_xattr, "user_xattr"},
 203         {Opt_nouser_xattr, "nouser_xattr"},
 204         {Opt_acl, "acl"},
 205         {Opt_noacl, "noacl"},
 206         {Opt_active_logs, "active_logs=%u"},
 207         {Opt_disable_ext_identify, "disable_ext_identify"},
 208         {Opt_inline_xattr, "inline_xattr"},
 209         {Opt_noinline_xattr, "noinline_xattr"},
 210         {Opt_inline_xattr_size, "inline_xattr_size=%u"},
 211         {Opt_inline_data, "inline_data"},
 212         {Opt_inline_dentry, "inline_dentry"},
 213         {Opt_noinline_dentry, "noinline_dentry"},
 214         {Opt_flush_merge, "flush_merge"},
 215         {Opt_noflush_merge, "noflush_merge"},
 216         {Opt_barrier, "barrier"},
 217         {Opt_nobarrier, "nobarrier"},
 218         {Opt_fastboot, "fastboot"},
 219         {Opt_extent_cache, "extent_cache"},
 220         {Opt_noextent_cache, "noextent_cache"},
 221         {Opt_noinline_data, "noinline_data"},
 222         {Opt_data_flush, "data_flush"},
 223         {Opt_reserve_root, "reserve_root=%u"},
 224         {Opt_resgid, "resgid=%u"},
 225         {Opt_resuid, "resuid=%u"},
 226         {Opt_mode, "mode=%s"},
 227         {Opt_fault_injection, "fault_injection=%u"},
 228         {Opt_fault_type, "fault_type=%u"},
 229         {Opt_quota, "quota"},
 230         {Opt_noquota, "noquota"},
 231         {Opt_usrquota, "usrquota"},
 232         {Opt_grpquota, "grpquota"},
 233         {Opt_prjquota, "prjquota"},
 234         {Opt_usrjquota, "usrjquota=%s"},
 235         {Opt_grpjquota, "grpjquota=%s"},
 236         {Opt_prjjquota, "prjjquota=%s"},
 237         {Opt_offusrjquota, "usrjquota="},
 238         {Opt_offgrpjquota, "grpjquota="},
 239         {Opt_offprjjquota, "prjjquota="},
 240         {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
 241         {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
 242         {Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
 243         {Opt_alloc, "alloc_mode=%s"},
 244         {Opt_fsync, "fsync_mode=%s"},
 245         {Opt_test_dummy_encryption, "test_dummy_encryption=%s"},
 246         {Opt_test_dummy_encryption, "test_dummy_encryption"},
 247         {Opt_inlinecrypt, "inlinecrypt"},
 248         {Opt_checkpoint_disable, "checkpoint=disable"},
 249         {Opt_checkpoint_disable_cap, "checkpoint=disable:%u"},
 250         {Opt_checkpoint_disable_cap_perc, "checkpoint=disable:%u%%"},
 251         {Opt_checkpoint_enable, "checkpoint=enable"},
 252         {Opt_checkpoint_merge, "checkpoint_merge"},
 253         {Opt_nocheckpoint_merge, "nocheckpoint_merge"},
 254         {Opt_compress_algorithm, "compress_algorithm=%s"},
 255         {Opt_compress_log_size, "compress_log_size=%u"},
 256         {Opt_compress_extension, "compress_extension=%s"},
 257         {Opt_nocompress_extension, "nocompress_extension=%s"},
 258         {Opt_compress_chksum, "compress_chksum"},
 259         {Opt_compress_mode, "compress_mode=%s"},
 260         {Opt_compress_cache, "compress_cache"},
 261         {Opt_atgc, "atgc"},
 262         {Opt_gc_merge, "gc_merge"},
 263         {Opt_nogc_merge, "nogc_merge"},
 264         {Opt_discard_unit, "discard_unit=%s"},
 265         {Opt_memory_mode, "memory=%s"},
 266         {Opt_age_extent_cache, "age_extent_cache"},
 267         {Opt_errors, "errors=%s"},
 268         {Opt_err, NULL},
 269 };
 270
 271 void f2fs_printk(struct f2fs_sb_info *sbi, bool limit_rate,
 272                                                 const char *fmt, ...)
 273 {
 274         struct va_format vaf;
 275         va_list args;
 276         int level;
 277
 278         va_start(args, fmt);
 279
 280         level = printk_get_level(fmt);
 281         vaf.fmt = printk_skip_level(fmt);
 282         vaf.va = &args;
 283         if (limit_rate)
 284                 printk_ratelimited("%c%cF2FS-fs (%s): %pV\n",
 285                         KERN_SOH_ASCII, level, sbi->sb->s_id, &vaf);
 286         else
 287                 printk("%c%cF2FS-fs (%s): %pV\n",
 288                         KERN_SOH_ASCII, level, sbi->sb->s_id, &vaf);
 289
 290         va_end(args);
 291 }
 292
 293 #if IS_ENABLED(CONFIG_UNICODE)
 294 static const struct f2fs_sb_encodings {
 295         __u16 magic;
 296         char *name;
 297         unsigned int version;
 298 } f2fs_sb_encoding_map[] = {
 299         {F2FS_ENC_UTF8_12_1, "utf8", UNICODE_AGE(12, 1, 0)},
 300 };
 301
 302 static const struct f2fs_sb_encodings *
 303 f2fs_sb_read_encoding(const struct f2fs_super_block *sb)
 304 {
 305         __u16 magic = le16_to_cpu(sb->s_encoding);
 306         int i;
 307
 308         for (i = 0; i < ARRAY_SIZE(f2fs_sb_encoding_map); i++)
 309                 if (magic == f2fs_sb_encoding_map[i].magic)
 310                         return &f2fs_sb_encoding_map[i];
 311
 312         return NULL;
 313 }
 314
 315 struct kmem_cache *f2fs_cf_name_slab;
 316 static int __init f2fs_create_casefold_cache(void)
 317 {
 318         f2fs_cf_name_slab = f2fs_kmem_cache_create("f2fs_casefolded_name",
 319                                                    F2FS_NAME_LEN);
 320         return f2fs_cf_name_slab ? 0 : -ENOMEM;
 321 }
 322
 323 static void f2fs_destroy_casefold_cache(void)
 324 {
 325         kmem_cache_destroy(f2fs_cf_name_slab);
 326 }
 327 #else
 328 static int __init f2fs_create_casefold_cache(void) { return 0; }
 329 static void f2fs_destroy_casefold_cache(void) { }
 330 #endif
 331
 332 static inline void limit_reserve_root(struct f2fs_sb_info *sbi)
 333 {
 334         block_t limit = min((sbi->user_block_count >> 3),
 335                         sbi->user_block_count - sbi->reserved_blocks);
 336
 337         /* limit is 12.5% */
 338         if (test_opt(sbi, RESERVE_ROOT) &&
 339                         F2FS_OPTION(sbi).root_reserved_blocks > limit) {
 340                 F2FS_OPTION(sbi).root_reserved_blocks = limit;
 341                 f2fs_info(sbi, "Reduce reserved blocks for root = %u",
 342                           F2FS_OPTION(sbi).root_reserved_blocks);
 343         }
 344         if (!test_opt(sbi, RESERVE_ROOT) &&
 345                 (!uid_eq(F2FS_OPTION(sbi).s_resuid,
 346                                 make_kuid(&init_user_ns, F2FS_DEF_RESUID)) ||
 347                 !gid_eq(F2FS_OPTION(sbi).s_resgid,
 348                                 make_kgid(&init_user_ns, F2FS_DEF_RESGID))))
 349                 f2fs_info(sbi, "Ignore s_resuid=%u, s_resgid=%u w/o reserve_root",
 350                           from_kuid_munged(&init_user_ns,
 351                                            F2FS_OPTION(sbi).s_resuid),
 352                           from_kgid_munged(&init_user_ns,
 353                                            F2FS_OPTION(sbi).s_resgid));
 354 }
 355
 356 static inline void adjust_unusable_cap_perc(struct f2fs_sb_info *sbi)
 357 {
 358         if (!F2FS_OPTION(sbi).unusable_cap_perc)
 359                 return;
 360
 361         if (F2FS_OPTION(sbi).unusable_cap_perc == 100)
 362                 F2FS_OPTION(sbi).unusable_cap = sbi->user_block_count;
 363         else
 364                 F2FS_OPTION(sbi).unusable_cap = (sbi->user_block_count / 100) *
 365                                         F2FS_OPTION(sbi).unusable_cap_perc;
 366
 367         f2fs_info(sbi, "Adjust unusable cap for checkpoint=disable = %u / %u%%",
 368                         F2FS_OPTION(sbi).unusable_cap,
 369                         F2FS_OPTION(sbi).unusable_cap_perc);
 370 }
 371
 372 static void init_once(void *foo)
 373 {
 374         struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;
 375
 376         inode_init_once(&fi->vfs_inode);
 377 }
 378
 379 #ifdef CONFIG_QUOTA
 380 static const char * const quotatypes[] = INITQFNAMES;
 381 #define QTYPE2NAME(t) (quotatypes[t])
 382 static int f2fs_set_qf_name(struct super_block *sb, int qtype,
 383                                                         substring_t *args)
 384 {
 385         struct f2fs_sb_info *sbi = F2FS_SB(sb);
 386         char *qname;
 387         int ret = -EINVAL;
 388
 389         if (sb_any_quota_loaded(sb) && !F2FS_OPTION(sbi).s_qf_names[qtype]) {
 390                 f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");
 391                 return -EINVAL;
 392         }
 393         if (f2fs_sb_has_quota_ino(sbi)) {
 394                 f2fs_info(sbi, "QUOTA feature is enabled, so ignore qf_name");
 395                 return 0;
 396         }
 397
 398         qname = match_strdup(args);
 399         if (!qname) {
 400                 f2fs_err(sbi, "Not enough memory for storing quotafile name");
 401                 return -ENOMEM;
 402         }
 403         if (F2FS_OPTION(sbi).s_qf_names[qtype]) {
 404                 if (strcmp(F2FS_OPTION(sbi).s_qf_names[qtype], qname) == 0)
 405                         ret = 0;
 406                 else
 407                         f2fs_err(sbi, "%s quota file already specified",
 408                                  QTYPE2NAME(qtype));
 409                 goto errout;
 410         }
 411         if (strchr(qname, '/')) {
 412                 f2fs_err(sbi, "quotafile must be on filesystem root");
 413                 goto errout;
 414         }
 415         F2FS_OPTION(sbi).s_qf_names[qtype] = qname;
 416         set_opt(sbi, QUOTA);
 417         return 0;
 418 errout:
 419         kfree(qname);
 420         return ret;
 421 }
 422
 423 static int f2fs_clear_qf_name(struct super_block *sb, int qtype)
 424 {
 425         struct f2fs_sb_info *sbi = F2FS_SB(sb);
 426
 427         if (sb_any_quota_loaded(sb) && F2FS_OPTION(sbi).s_qf_names[qtype]) {
 428                 f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");
 429                 return -EINVAL;
 430         }
 431         kfree(F2FS_OPTION(sbi).s_qf_names[qtype]);
 432         F2FS_OPTION(sbi).s_qf_names[qtype] = NULL;
 433         return 0;
 434 }
 435
 436 static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
 437 {
 438         /*
 439          * We do the test below only for project quotas. 'usrquota' and
 440          * 'grpquota' mount options are allowed even without quota feature
 441          * to support legacy quotas in quota files.
 442          */
 443         if (test_opt(sbi, PRJQUOTA) && !f2fs_sb_has_project_quota(sbi)) {
 444                 f2fs_err(sbi, "Project quota feature not enabled. Cannot enable project quota enforcement.");
 445                 return -1;
 446         }
 447         if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||
 448                         F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||
 449                         F2FS_OPTION(sbi).s_qf_names[PRJQUOTA]) {
 450                 if (test_opt(sbi, USRQUOTA) &&
 451                                 F2FS_OPTION(sbi).s_qf_names[USRQUOTA])
 452                         clear_opt(sbi, USRQUOTA);
 453
 454                 if (test_opt(sbi, GRPQUOTA) &&
 455                                 F2FS_OPTION(sbi).s_qf_names[GRPQUOTA])
 456                         clear_opt(sbi, GRPQUOTA);
 457
 458                 if (test_opt(sbi, PRJQUOTA) &&
 459                                 F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])
 460                         clear_opt(sbi, PRJQUOTA);
 461
 462                 if (test_opt(sbi, GRPQUOTA) || test_opt(sbi, USRQUOTA) ||
 463                                 test_opt(sbi, PRJQUOTA)) {
 464                         f2fs_err(sbi, "old and new quota format mixing");
 465                         return -1;
 466                 }
 467
 468                 if (!F2FS_OPTION(sbi).s_jquota_fmt) {
 469                         f2fs_err(sbi, "journaled quota format not specified");
 470                         return -1;
 471                 }
 472         }
 473
 474         if (f2fs_sb_has_quota_ino(sbi) && F2FS_OPTION(sbi).s_jquota_fmt) {
 475                 f2fs_info(sbi, "QUOTA feature is enabled, so ignore jquota_fmt");
 476                 F2FS_OPTION(sbi).s_jquota_fmt = 0;
 477         }
 478         return 0;
 479 }
 480 #endif
 481
 482 static int f2fs_set_test_dummy_encryption(struct super_block *sb,
 483                                           const char *opt,
 484                                           const substring_t *arg,
 485                                           bool is_remount)
 486 {
 487         struct f2fs_sb_info *sbi = F2FS_SB(sb);
 488         struct fs_parameter param = {
 489                 .type = fs_value_is_string,
 490                 .string = arg->from ? arg->from : "",
 491         };
 492         struct fscrypt_dummy_policy *policy =
 493                 &F2FS_OPTION(sbi).dummy_enc_policy;
 494         int err;
 495
 496         if (!IS_ENABLED(CONFIG_FS_ENCRYPTION)) {
 497                 f2fs_warn(sbi, "test_dummy_encryption option not supported");
 498                 return -EINVAL;
 499         }
 500
 501         if (!f2fs_sb_has_encrypt(sbi)) {
 502                 f2fs_err(sbi, "Encrypt feature is off");
 503                 return -EINVAL;
 504         }
 505
 506         /*
 507          * This mount option is just for testing, and it's not worthwhile to
 508          * implement the extra complexity (e.g. RCU protection) that would be
 509          * needed to allow it to be set or changed during remount.  We do allow
 510          * it to be specified during remount, but only if there is no change.
 511          */
 512         if (is_remount && !fscrypt_is_dummy_policy_set(policy)) {
 513                 f2fs_warn(sbi, "Can't set test_dummy_encryption on remount");
 514                 return -EINVAL;
 515         }
 516
 517         err = fscrypt_parse_test_dummy_encryption(&param, policy);
 518         if (err) {
 519                 if (err == -EEXIST)
 520                         f2fs_warn(sbi,
 521                                   "Can't change test_dummy_encryption on remount");
 522                 else if (err == -EINVAL)
 523                         f2fs_warn(sbi, "Value of option \"%s\" is unrecognized",
 524                                   opt);
 525                 else
 526                         f2fs_warn(sbi, "Error processing option \"%s\" [%d]",
 527                                   opt, err);
 528                 return -EINVAL;
 529         }
 530         f2fs_warn(sbi, "Test dummy encryption mode enabled");
 531         return 0;
 532 }
 533
 534 #ifdef CONFIG_F2FS_FS_COMPRESSION
 535 static bool is_compress_extension_exist(struct f2fs_sb_info *sbi,
 536                                         const char *new_ext, bool is_ext)
 537 {
 538         unsigned char (*ext)[F2FS_EXTENSION_LEN];
 539         int ext_cnt;
 540         int i;
 541
 542         if (is_ext) {
 543                 ext = F2FS_OPTION(sbi).extensions;
 544                 ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
 545         } else {
 546                 ext = F2FS_OPTION(sbi).noextensions;
 547                 ext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
 548         }
 549
 550         for (i = 0; i < ext_cnt; i++) {
 551                 if (!strcasecmp(new_ext, ext[i]))
 552                         return true;
 553         }
 554
 555         return false;
 556 }
 557
 558 /*
 559  * 1. The same extension name cannot not appear in both compress and non-compress extension
 560  * at the same time.
 561  * 2. If the compress extension specifies all files, the types specified by the non-compress
 562  * extension will be treated as special cases and will not be compressed.
 563  * 3. Don't allow the non-compress extension specifies all files.
 564  */
 565 static int f2fs_test_compress_extension(struct f2fs_sb_info *sbi)
 566 {
 567         unsigned char (*ext)[F2FS_EXTENSION_LEN];
 568         unsigned char (*noext)[F2FS_EXTENSION_LEN];
 569         int ext_cnt, noext_cnt, index = 0, no_index = 0;
 570
 571         ext = F2FS_OPTION(sbi).extensions;
 572         ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
 573         noext = F2FS_OPTION(sbi).noextensions;
 574         noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
 575
 576         if (!noext_cnt)
 577                 return 0;
 578
 579         for (no_index = 0; no_index < noext_cnt; no_index++) {
 580                 if (!strcasecmp("*", noext[no_index])) {
 581                         f2fs_info(sbi, "Don't allow the nocompress extension specifies all files");
 582                         return -EINVAL;
 583                 }
 584                 for (index = 0; index < ext_cnt; index++) {
 585                         if (!strcasecmp(ext[index], noext[no_index])) {
 586                                 f2fs_info(sbi, "Don't allow the same extension %s appear in both compress and nocompress extension",
 587                                                 ext[index]);
 588                                 return -EINVAL;
 589                         }
 590                 }
 591         }
 592         return 0;
 593 }
 594
 595 #ifdef CONFIG_F2FS_FS_LZ4
 596 static int f2fs_set_lz4hc_level(struct f2fs_sb_info *sbi, const char *str)
 597 {
 598 #ifdef CONFIG_F2FS_FS_LZ4HC
 599         unsigned int level;
 600
 601         if (strlen(str) == 3) {
 602                 F2FS_OPTION(sbi).compress_level = 0;
 603                 return 0;
 604         }
 605
 606         str += 3;
 607
 608         if (str[0] != ':') {
 609                 f2fs_info(sbi, "wrong format, e.g. <alg_name>:<compr_level>");
 610                 return -EINVAL;
 611         }
 612         if (kstrtouint(str + 1, 10, &level))
 613                 return -EINVAL;
 614
 615         if (!f2fs_is_compress_level_valid(COMPRESS_LZ4, level)) {
 616                 f2fs_info(sbi, "invalid lz4hc compress level: %d", level);
 617                 return -EINVAL;
 618         }
 619
 620         F2FS_OPTION(sbi).compress_level = level;
 621         return 0;
 622 #else
 623         if (strlen(str) == 3) {
 624                 F2FS_OPTION(sbi).compress_level = 0;
 625                 return 0;
 626         }
 627         f2fs_info(sbi, "kernel doesn't support lz4hc compression");
 628         return -EINVAL;
 629 #endif
 630 }
 631 #endif
 632
 633 #ifdef CONFIG_F2FS_FS_ZSTD
 634 static int f2fs_set_zstd_level(struct f2fs_sb_info *sbi, const char *str)
 635 {
 636         int level;
 637         int len = 4;
 638
 639         if (strlen(str) == len) {
 640                 F2FS_OPTION(sbi).compress_level = F2FS_ZSTD_DEFAULT_CLEVEL;
 641                 return 0;
 642         }
 643
 644         str += len;
 645
 646         if (str[0] != ':') {
 647                 f2fs_info(sbi, "wrong format, e.g. <alg_name>:<compr_level>");
 648                 return -EINVAL;
 649         }
 650         if (kstrtoint(str + 1, 10, &level))
 651                 return -EINVAL;
 652
 653         /* f2fs does not support negative compress level now */
 654         if (level < 0) {
 655                 f2fs_info(sbi, "do not support negative compress level: %d", level);
 656                 return -ERANGE;
 657         }
 658
 659         if (!f2fs_is_compress_level_valid(COMPRESS_ZSTD, level)) {
 660                 f2fs_info(sbi, "invalid zstd compress level: %d", level);
 661                 return -EINVAL;
 662         }
 663
 664         F2FS_OPTION(sbi).compress_level = level;
 665         return 0;
 666 }
 667 #endif
 668 #endif
 669
 670 static int parse_options(struct super_block *sb, char *options, bool is_remount)
 671 {
 672         struct f2fs_sb_info *sbi = F2FS_SB(sb);
 673         substring_t args[MAX_OPT_ARGS];
 674 #ifdef CONFIG_F2FS_FS_COMPRESSION
 675         unsigned char (*ext)[F2FS_EXTENSION_LEN];
 676         unsigned char (*noext)[F2FS_EXTENSION_LEN];
 677         int ext_cnt, noext_cnt;
 678 #endif
 679         char *p, *name;
 680         int arg = 0;
 681         kuid_t uid;
 682         kgid_t gid;
 683         int ret;
 684
 685         if (!options)
 686                 goto default_check;
 687
 688         while ((p = strsep(&options, ",")) != NULL) {
 689                 int token;
 690
 691                 if (!*p)
 692                         continue;
 693                 /*
 694                  * Initialize args struct so we know whether arg was
 695                  * found; some options take optional arguments.
 696                  */
 697                 args[0].to = args[0].from = NULL;
 698                 token = match_token(p, f2fs_tokens, args);
 699
 700                 switch (token) {
 701                 case Opt_gc_background:
 702                         name = match_strdup(&args[0]);
 703
 704                         if (!name)
 705                                 return -ENOMEM;
 706                         if (!strcmp(name, "on")) {
 707                                 F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ON;
 708                         } else if (!strcmp(name, "off")) {
 709                                 if (f2fs_sb_has_blkzoned(sbi)) {
 710                                         f2fs_warn(sbi, "zoned devices need bggc");
 711                                         kfree(name);
 712                                         return -EINVAL;
 713                                 }
 714                                 F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_OFF;
 715                         } else if (!strcmp(name, "sync")) {
 716                                 F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_SYNC;
 717                         } else {
 718                                 kfree(name);
 719                                 return -EINVAL;
 720                         }
 721                         kfree(name);
 722                         break;
 723                 case Opt_disable_roll_forward:
 724                         set_opt(sbi, DISABLE_ROLL_FORWARD);
 725                         break;
 726                 case Opt_norecovery:
 727                         /* this option mounts f2fs with ro */
 728                         set_opt(sbi, NORECOVERY);
 729                         if (!f2fs_readonly(sb))
 730                                 return -EINVAL;
 731                         break;
 732                 case Opt_discard:
 733                         if (!f2fs_hw_support_discard(sbi)) {
 734                                 f2fs_warn(sbi, "device does not support discard");
 735                                 break;
 736                         }
 737                         set_opt(sbi, DISCARD);
 738                         break;
 739                 case Opt_nodiscard:
 740                         if (f2fs_hw_should_discard(sbi)) {
 741                                 f2fs_warn(sbi, "discard is required for zoned block devices");
 742                                 return -EINVAL;
 743                         }
 744                         clear_opt(sbi, DISCARD);
 745                         break;
 746                 case Opt_noheap:
 747                 case Opt_heap:
 748                         f2fs_warn(sbi, "heap/no_heap options were deprecated");
 749                         break;
 750 #ifdef CONFIG_F2FS_FS_XATTR
 751                 case Opt_user_xattr:
 752                         set_opt(sbi, XATTR_USER);
 753                         break;
 754                 case Opt_nouser_xattr:
 755                         clear_opt(sbi, XATTR_USER);
 756                         break;
 757                 case Opt_inline_xattr:
 758                         set_opt(sbi, INLINE_XATTR);
 759                         break;
 760                 case Opt_noinline_xattr:
 761                         clear_opt(sbi, INLINE_XATTR);
 762                         break;
 763                 case Opt_inline_xattr_size:
 764                         if (args->from && match_int(args, &arg))
 765                                 return -EINVAL;
 766                         set_opt(sbi, INLINE_XATTR_SIZE);
 767                         F2FS_OPTION(sbi).inline_xattr_size = arg;
 768                         break;
 769 #else
 770                 case Opt_user_xattr:
 771                         f2fs_info(sbi, "user_xattr options not supported");
 772                         break;
 773                 case Opt_nouser_xattr:
 774                         f2fs_info(sbi, "nouser_xattr options not supported");
 775                         break;
 776                 case Opt_inline_xattr:
 777                         f2fs_info(sbi, "inline_xattr options not supported");
 778                         break;
 779                 case Opt_noinline_xattr:
 780                         f2fs_info(sbi, "noinline_xattr options not supported");
 781                         break;
 782 #endif
 783 #ifdef CONFIG_F2FS_FS_POSIX_ACL
 784                 case Opt_acl:
 785                         set_opt(sbi, POSIX_ACL);
 786                         break;
 787                 case Opt_noacl:
 788                         clear_opt(sbi, POSIX_ACL);
 789                         break;
 790 #else
 791                 case Opt_acl:
 792                         f2fs_info(sbi, "acl options not supported");
 793                         break;
 794                 case Opt_noacl:
 795                         f2fs_info(sbi, "noacl options not supported");
 796                         break;
 797 #endif
 798                 case Opt_active_logs:
 799                         if (args->from && match_int(args, &arg))
 800                                 return -EINVAL;
 801                         if (arg != 2 && arg != 4 &&
 802                                 arg != NR_CURSEG_PERSIST_TYPE)
 803                                 return -EINVAL;
 804                         F2FS_OPTION(sbi).active_logs = arg;
 805                         break;
 806                 case Opt_disable_ext_identify:
 807                         set_opt(sbi, DISABLE_EXT_IDENTIFY);
 808                         break;
 809                 case Opt_inline_data:
 810                         set_opt(sbi, INLINE_DATA);
 811                         break;
 812                 case Opt_inline_dentry:
 813                         set_opt(sbi, INLINE_DENTRY);
 814                         break;
 815                 case Opt_noinline_dentry:
 816                         clear_opt(sbi, INLINE_DENTRY);
 817                         break;
 818                 case Opt_flush_merge:
 819                         set_opt(sbi, FLUSH_MERGE);
 820                         break;
 821                 case Opt_noflush_merge:
 822                         clear_opt(sbi, FLUSH_MERGE);
 823                         break;
 824                 case Opt_nobarrier:
 825                         set_opt(sbi, NOBARRIER);
 826                         break;
 827                 case Opt_barrier:
 828                         clear_opt(sbi, NOBARRIER);
 829                         break;
 830                 case Opt_fastboot:
 831                         set_opt(sbi, FASTBOOT);
 832                         break;
 833                 case Opt_extent_cache:
 834                         set_opt(sbi, READ_EXTENT_CACHE);
 835                         break;
 836                 case Opt_noextent_cache:
 837                         clear_opt(sbi, READ_EXTENT_CACHE);
 838                         break;
 839                 case Opt_noinline_data:
 840                         clear_opt(sbi, INLINE_DATA);
 841                         break;
 842                 case Opt_data_flush:
 843                         set_opt(sbi, DATA_FLUSH);
 844                         break;
 845                 case Opt_reserve_root:
 846                         if (args->from && match_int(args, &arg))
 847                                 return -EINVAL;
 848                         if (test_opt(sbi, RESERVE_ROOT)) {
 849                                 f2fs_info(sbi, "Preserve previous reserve_root=%u",
 850                                           F2FS_OPTION(sbi).root_reserved_blocks);
 851                         } else {
 852                                 F2FS_OPTION(sbi).root_reserved_blocks = arg;
 853                                 set_opt(sbi, RESERVE_ROOT);
 854                         }
 855                         break;
 856                 case Opt_resuid:
 857                         if (args->from && match_int(args, &arg))
 858                                 return -EINVAL;
 859                         uid = make_kuid(current_user_ns(), arg);
 860                         if (!uid_valid(uid)) {
 861                                 f2fs_err(sbi, "Invalid uid value %d", arg);
 862                                 return -EINVAL;
 863                         }
 864                         F2FS_OPTION(sbi).s_resuid = uid;
 865                         break;
 866                 case Opt_resgid:
 867                         if (args->from && match_int(args, &arg))
 868                                 return -EINVAL;
 869                         gid = make_kgid(current_user_ns(), arg);
 870                         if (!gid_valid(gid)) {
 871                                 f2fs_err(sbi, "Invalid gid value %d", arg);
 872                                 return -EINVAL;
 873                         }
 874                         F2FS_OPTION(sbi).s_resgid = gid;
 875                         break;
 876                 case Opt_mode:
 877                         name = match_strdup(&args[0]);
 878
 879                         if (!name)
 880                                 return -ENOMEM;
 881                         if (!strcmp(name, "adaptive")) {
 882                                 F2FS_OPTION(sbi).fs_mode = FS_MODE_ADAPTIVE;
 883                         } else if (!strcmp(name, "lfs")) {
 884                                 F2FS_OPTION(sbi).fs_mode = FS_MODE_LFS;
 885                         } else if (!strcmp(name, "fragment:segment")) {
 886                                 F2FS_OPTION(sbi).fs_mode = FS_MODE_FRAGMENT_SEG;
 887                         } else if (!strcmp(name, "fragment:block")) {
 888                                 F2FS_OPTION(sbi).fs_mode = FS_MODE_FRAGMENT_BLK;
 889                         } else {
 890                                 kfree(name);
 891                                 return -EINVAL;
 892                         }
 893                         kfree(name);
 894                         break;
 895 #ifdef CONFIG_F2FS_FAULT_INJECTION
 896                 case Opt_fault_injection:
 897                         if (args->from && match_int(args, &arg))
 898                                 return -EINVAL;
 899                         if (f2fs_build_fault_attr(sbi, arg,
 900                                         F2FS_ALL_FAULT_TYPE))
 901                                 return -EINVAL;
 902                         set_opt(sbi, FAULT_INJECTION);
 903                         break;
 904
 905                 case Opt_fault_type:
 906                         if (args->from && match_int(args, &arg))
 907                                 return -EINVAL;
 908                         if (f2fs_build_fault_attr(sbi, 0, arg))
 909                                 return -EINVAL;
 910                         set_opt(sbi, FAULT_INJECTION);
 911                         break;
 912 #else
 913                 case Opt_fault_injection:
 914                         f2fs_info(sbi, "fault_injection options not supported");
 915                         break;
 916
 917                 case Opt_fault_type:
 918                         f2fs_info(sbi, "fault_type options not supported");
 919                         break;
 920 #endif
 921 #ifdef CONFIG_QUOTA
 922                 case Opt_quota:
 923                 case Opt_usrquota:
 924                         set_opt(sbi, USRQUOTA);
 925                         break;
 926                 case Opt_grpquota:
 927                         set_opt(sbi, GRPQUOTA);
 928                         break;
 929                 case Opt_prjquota:
 930                         set_opt(sbi, PRJQUOTA);
 931                         break;
 932                 case Opt_usrjquota:
 933                         ret = f2fs_set_qf_name(sb, USRQUOTA, &args[0]);
 934                         if (ret)
 935                                 return ret;
 936                         break;
 937                 case Opt_grpjquota:
 938                         ret = f2fs_set_qf_name(sb, GRPQUOTA, &args[0]);
 939                         if (ret)
 940                                 return ret;
 941                         break;
 942                 case Opt_prjjquota:
 943                         ret = f2fs_set_qf_name(sb, PRJQUOTA, &args[0]);
 944                         if (ret)
 945                                 return ret;
 946                         break;
 947                 case Opt_offusrjquota:
 948                         ret = f2fs_clear_qf_name(sb, USRQUOTA);
 949                         if (ret)
 950                                 return ret;
 951                         break;
 952                 case Opt_offgrpjquota:
 953                         ret = f2fs_clear_qf_name(sb, GRPQUOTA);
 954                         if (ret)
 955                                 return ret;
 956                         break;
 957                 case Opt_offprjjquota:
 958                         ret = f2fs_clear_qf_name(sb, PRJQUOTA);
 959                         if (ret)
 960                                 return ret;
 961                         break;
 962                 case Opt_jqfmt_vfsold:
 963                         F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_OLD;
 964                         break;
 965                 case Opt_jqfmt_vfsv0:
 966                         F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V0;
 967                         break;
 968                 case Opt_jqfmt_vfsv1:
 969                         F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V1;
 970                         break;
 971                 case Opt_noquota:
 972                         clear_opt(sbi, QUOTA);
 973                         clear_opt(sbi, USRQUOTA);
 974                         clear_opt(sbi, GRPQUOTA);
 975                         clear_opt(sbi, PRJQUOTA);
 976                         break;
 977 #else
 978                 case Opt_quota:
 979                 case Opt_usrquota:
 980                 case Opt_grpquota:
 981                 case Opt_prjquota:
 982                 case Opt_usrjquota:
 983                 case Opt_grpjquota:
 984                 case Opt_prjjquota:
 985                 case Opt_offusrjquota:
 986                 case Opt_offgrpjquota:
 987                 case Opt_offprjjquota:
 988                 case Opt_jqfmt_vfsold:
 989                 case Opt_jqfmt_vfsv0:
 990                 case Opt_jqfmt_vfsv1:
 991                 case Opt_noquota:
 992                         f2fs_info(sbi, "quota operations not supported");
 993                         break;
 994 #endif
 995                 case Opt_alloc:
 996                         name = match_strdup(&args[0]);
 997                         if (!name)
 998                                 return -ENOMEM;
 999
1000                         if (!strcmp(name, "default")) {
1001                                 F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;
1002                         } else if (!strcmp(name, "reuse")) {
1003                                 F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
1004                         } else {
1005                                 kfree(name);
1006                                 return -EINVAL;
1007                         }
1008                         kfree(name);
1009                         break;
1010                 case Opt_fsync:
1011                         name = match_strdup(&args[0]);
1012                         if (!name)
1013                                 return -ENOMEM;
1014                         if (!strcmp(name, "posix")) {
1015                                 F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;
1016                         } else if (!strcmp(name, "strict")) {
1017                                 F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_STRICT;
1018                         } else if (!strcmp(name, "nobarrier")) {
1019                                 F2FS_OPTION(sbi).fsync_mode =
1020                                                         FSYNC_MODE_NOBARRIER;
1021                         } else {
1022                                 kfree(name);
1023                                 return -EINVAL;
1024                         }
1025                         kfree(name);
1026                         break;
1027                 case Opt_test_dummy_encryption:
1028                         ret = f2fs_set_test_dummy_encryption(sb, p, &args[0],
1029                                                              is_remount);
1030                         if (ret)
1031                                 return ret;
1032                         break;
1033                 case Opt_inlinecrypt:
1034 #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
1035                         sb->s_flags |= SB_INLINECRYPT;
1036 #else
1037                         f2fs_info(sbi, "inline encryption not supported");
1038 #endif
1039                         break;
1040                 case Opt_checkpoint_disable_cap_perc:
1041                         if (args->from && match_int(args, &arg))
1042                                 return -EINVAL;
1043                         if (arg < 0 || arg > 100)
1044                                 return -EINVAL;
1045                         F2FS_OPTION(sbi).unusable_cap_perc = arg;
1046                         set_opt(sbi, DISABLE_CHECKPOINT);
1047                         break;
1048                 case Opt_checkpoint_disable_cap:
1049                         if (args->from && match_int(args, &arg))
1050                                 return -EINVAL;
1051                         F2FS_OPTION(sbi).unusable_cap = arg;
1052                         set_opt(sbi, DISABLE_CHECKPOINT);
1053                         break;
1054                 case Opt_checkpoint_disable:
1055                         set_opt(sbi, DISABLE_CHECKPOINT);
1056                         break;
1057                 case Opt_checkpoint_enable:
1058                         clear_opt(sbi, DISABLE_CHECKPOINT);
1059                         break;
1060                 case Opt_checkpoint_merge:
1061                         set_opt(sbi, MERGE_CHECKPOINT);
1062                         break;
1063                 case Opt_nocheckpoint_merge:
1064                         clear_opt(sbi, MERGE_CHECKPOINT);
1065                         break;
1066 #ifdef CONFIG_F2FS_FS_COMPRESSION
1067                 case Opt_compress_algorithm:
1068                         if (!f2fs_sb_has_compression(sbi)) {
1069                                 f2fs_info(sbi, "Image doesn't support compression");
1070                                 break;
1071                         }
1072                         name = match_strdup(&args[0]);
1073                         if (!name)
1074                                 return -ENOMEM;
1075                         if (!strcmp(name, "lzo")) {
1076 #ifdef CONFIG_F2FS_FS_LZO
1077                                 F2FS_OPTION(sbi).compress_level = 0;
1078                                 F2FS_OPTION(sbi).compress_algorithm =
1079                                                                 COMPRESS_LZO;
1080 #else
1081                                 f2fs_info(sbi, "kernel doesn't support lzo compression");
1082 #endif
1083                         } else if (!strncmp(name, "lz4", 3)) {
1084 #ifdef CONFIG_F2FS_FS_LZ4
1085                                 ret = f2fs_set_lz4hc_level(sbi, name);
1086                                 if (ret) {
1087                                         kfree(name);
1088                                         return -EINVAL;
1089                                 }
1090                                 F2FS_OPTION(sbi).compress_algorithm =
1091                                                                 COMPRESS_LZ4;
1092 #else
1093                                 f2fs_info(sbi, "kernel doesn't support lz4 compression");
1094 #endif
1095                         } else if (!strncmp(name, "zstd", 4)) {
1096 #ifdef CONFIG_F2FS_FS_ZSTD
1097                                 ret = f2fs_set_zstd_level(sbi, name);
1098                                 if (ret) {
1099                                         kfree(name);
1100                                         return -EINVAL;
1101                                 }
1102                                 F2FS_OPTION(sbi).compress_algorithm =
1103                                                                 COMPRESS_ZSTD;
1104 #else
1105                                 f2fs_info(sbi, "kernel doesn't support zstd compression");
1106 #endif
1107                         } else if (!strcmp(name, "lzo-rle")) {
1108 #ifdef CONFIG_F2FS_FS_LZORLE
1109                                 F2FS_OPTION(sbi).compress_level = 0;
1110                                 F2FS_OPTION(sbi).compress_algorithm =
1111                                                                 COMPRESS_LZORLE;
1112 #else
1113                                 f2fs_info(sbi, "kernel doesn't support lzorle compression");
1114 #endif
1115                         } else {
1116                                 kfree(name);
1117                                 return -EINVAL;
1118                         }
1119                         kfree(name);
1120                         break;
1121                 case Opt_compress_log_size:
1122                         if (!f2fs_sb_has_compression(sbi)) {
1123                                 f2fs_info(sbi, "Image doesn't support compression");
1124                                 break;
1125                         }
1126                         if (args->from && match_int(args, &arg))
1127                                 return -EINVAL;
1128                         if (arg < MIN_COMPRESS_LOG_SIZE ||
1129                                 arg > MAX_COMPRESS_LOG_SIZE) {
1130                                 f2fs_err(sbi,
1131                                         "Compress cluster log size is out of range");
1132                                 return -EINVAL;
1133                         }
1134                         F2FS_OPTION(sbi).compress_log_size = arg;
1135                         break;
1136                 case Opt_compress_extension:
1137                         if (!f2fs_sb_has_compression(sbi)) {
1138                                 f2fs_info(sbi, "Image doesn't support compression");
1139                                 break;
1140                         }
1141                         name = match_strdup(&args[0]);
1142                         if (!name)
1143                                 return -ENOMEM;
1144
1145                         ext = F2FS_OPTION(sbi).extensions;
1146                         ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
1147
1148                         if (strlen(name) >= F2FS_EXTENSION_LEN ||
1149                                 ext_cnt >= COMPRESS_EXT_NUM) {
1150                                 f2fs_err(sbi,
1151                                         "invalid extension length/number");
1152                                 kfree(name);
1153                                 return -EINVAL;
1154                         }
1155
1156                         if (is_compress_extension_exist(sbi, name, true)) {
1157                                 kfree(name);
1158                                 break;
1159                         }
1160
1161                         strcpy(ext[ext_cnt], name);
1162                         F2FS_OPTION(sbi).compress_ext_cnt++;
1163                         kfree(name);
1164                         break;
1165                 case Opt_nocompress_extension:
1166                         if (!f2fs_sb_has_compression(sbi)) {
1167                                 f2fs_info(sbi, "Image doesn't support compression");
1168                                 break;
1169                         }
1170                         name = match_strdup(&args[0]);
1171                         if (!name)
1172                                 return -ENOMEM;
1173
1174                         noext = F2FS_OPTION(sbi).noextensions;
1175                         noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;
1176
1177                         if (strlen(name) >= F2FS_EXTENSION_LEN ||
1178                                 noext_cnt >= COMPRESS_EXT_NUM) {
1179                                 f2fs_err(sbi,
1180                                         "invalid extension length/number");
1181                                 kfree(name);
1182                                 return -EINVAL;
1183                         }
1184
1185                         if (is_compress_extension_exist(sbi, name, false)) {
1186                                 kfree(name);
1187                                 break;
1188                         }
1189
1190                         strcpy(noext[noext_cnt], name);
1191                         F2FS_OPTION(sbi).nocompress_ext_cnt++;
1192                         kfree(name);
1193                         break;
1194                 case Opt_compress_chksum:
1195                         if (!f2fs_sb_has_compression(sbi)) {
1196                                 f2fs_info(sbi, "Image doesn't support compression");
1197                                 break;
1198                         }
1199                         F2FS_OPTION(sbi).compress_chksum = true;
1200                         break;
1201                 case Opt_compress_mode:
1202                         if (!f2fs_sb_has_compression(sbi)) {
1203                                 f2fs_info(sbi, "Image doesn't support compression");
1204                                 break;
1205                         }
1206                         name = match_strdup(&args[0]);
1207                         if (!name)
1208                                 return -ENOMEM;
1209                         if (!strcmp(name, "fs")) {
1210                                 F2FS_OPTION(sbi).compress_mode = COMPR_MODE_FS;
1211                         } else if (!strcmp(name, "user")) {
1212                                 F2FS_OPTION(sbi).compress_mode = COMPR_MODE_USER;
1213                         } else {
1214                                 kfree(name);
1215                                 return -EINVAL;
1216                         }
1217                         kfree(name);
1218                         break;
1219                 case Opt_compress_cache:
1220                         if (!f2fs_sb_has_compression(sbi)) {
1221                                 f2fs_info(sbi, "Image doesn't support compression");
1222                                 break;
1223                         }
1224                         set_opt(sbi, COMPRESS_CACHE);
1225                         break;
1226 #else
1227                 case Opt_compress_algorithm:
1228                 case Opt_compress_log_size:
1229                 case Opt_compress_extension:
1230                 case Opt_nocompress_extension:
1231                 case Opt_compress_chksum:
1232                 case Opt_compress_mode:
1233                 case Opt_compress_cache:
1234                         f2fs_info(sbi, "compression options not supported");
1235                         break;
1236 #endif
1237                 case Opt_atgc:
1238                         set_opt(sbi, ATGC);
1239                         break;
1240                 case Opt_gc_merge:
1241                         set_opt(sbi, GC_MERGE);
1242                         break;
1243                 case Opt_nogc_merge:
1244                         clear_opt(sbi, GC_MERGE);
1245                         break;
1246                 case Opt_discard_unit:
1247                         name = match_strdup(&args[0]);
1248                         if (!name)
1249                                 return -ENOMEM;
1250                         if (!strcmp(name, "block")) {
1251                                 F2FS_OPTION(sbi).discard_unit =
1252                                                 DISCARD_UNIT_BLOCK;
1253                         } else if (!strcmp(name, "segment")) {
1254                                 F2FS_OPTION(sbi).discard_unit =
1255                                                 DISCARD_UNIT_SEGMENT;
1256                         } else if (!strcmp(name, "section")) {
1257                                 F2FS_OPTION(sbi).discard_unit =
1258                                                 DISCARD_UNIT_SECTION;
1259                         } else {
1260                                 kfree(name);
1261                                 return -EINVAL;
1262                         }
1263                         kfree(name);
1264                         break;
1265                 case Opt_memory_mode:
1266                         name = match_strdup(&args[0]);
1267                         if (!name)
1268                                 return -ENOMEM;
1269                         if (!strcmp(name, "normal")) {
1270                                 F2FS_OPTION(sbi).memory_mode =
1271                                                 MEMORY_MODE_NORMAL;
1272                         } else if (!strcmp(name, "low")) {
1273                                 F2FS_OPTION(sbi).memory_mode =
1274                                                 MEMORY_MODE_LOW;
1275                         } else {
1276                                 kfree(name);
1277                                 return -EINVAL;
1278                         }
1279                         kfree(name);
1280                         break;
1281                 case Opt_age_extent_cache:
1282                         set_opt(sbi, AGE_EXTENT_CACHE);
1283                         break;
1284                 case Opt_errors:
1285                         name = match_strdup(&args[0]);
1286                         if (!name)
1287                                 return -ENOMEM;
1288                         if (!strcmp(name, "remount-ro")) {
1289                                 F2FS_OPTION(sbi).errors =
1290                                                 MOUNT_ERRORS_READONLY;
1291                         } else if (!strcmp(name, "continue")) {
1292                                 F2FS_OPTION(sbi).errors =
1293                                                 MOUNT_ERRORS_CONTINUE;
1294                         } else if (!strcmp(name, "panic")) {
1295                                 F2FS_OPTION(sbi).errors =
1296                                                 MOUNT_ERRORS_PANIC;
1297                         } else {
1298                                 kfree(name);
1299                                 return -EINVAL;
1300                         }
1301                         kfree(name);
1302                         break;
1303                 default:
1304                         f2fs_err(sbi, "Unrecognized mount option \"%s\" or missing value",
1305                                  p);
1306                         return -EINVAL;
1307                 }
1308         }
1309 default_check:
1310 #ifdef CONFIG_QUOTA
1311         if (f2fs_check_quota_options(sbi))
1312                 return -EINVAL;
1313 #else
1314         if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sbi->sb)) {
1315                 f2fs_info(sbi, "Filesystem with quota feature cannot be mounted RDWR without CONFIG_QUOTA");
1316                 return -EINVAL;
1317         }
1318         if (f2fs_sb_has_project_quota(sbi) && !f2fs_readonly(sbi->sb)) {
1319                 f2fs_err(sbi, "Filesystem with project quota feature cannot be mounted RDWR without CONFIG_QUOTA");
1320                 return -EINVAL;
1321         }
1322 #endif
1323
1324         if (!IS_ENABLED(CONFIG_UNICODE) && f2fs_sb_has_casefold(sbi)) {
1325                 f2fs_err(sbi,
1326                         "Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");
1327                 return -EINVAL;
1328         }
1329
1330         /*
1331          * The BLKZONED feature indicates that the drive was formatted with
1332          * zone alignment optimization. This is optional for host-aware
1333          * devices, but mandatory for host-managed zoned block devices.
1334          */
1335         if (f2fs_sb_has_blkzoned(sbi)) {
1336 #ifdef CONFIG_BLK_DEV_ZONED
1337                 if (F2FS_OPTION(sbi).discard_unit !=
1338                                                 DISCARD_UNIT_SECTION) {
1339                         f2fs_info(sbi, "Zoned block device doesn't need small discard, set discard_unit=section by default");
1340                         F2FS_OPTION(sbi).discard_unit =
1341                                         DISCARD_UNIT_SECTION;
1342                 }
1343
1344                 if (F2FS_OPTION(sbi).fs_mode != FS_MODE_LFS) {
1345                         f2fs_info(sbi, "Only lfs mode is allowed with zoned block device feature");
1346                         return -EINVAL;
1347                 }
1348 #else
1349                 f2fs_err(sbi, "Zoned block device support is not enabled");
1350                 return -EINVAL;
1351 #endif
1352         }
1353
1354 #ifdef CONFIG_F2FS_FS_COMPRESSION
1355         if (f2fs_test_compress_extension(sbi)) {
1356                 f2fs_err(sbi, "invalid compress or nocompress extension");
1357                 return -EINVAL;
1358         }
1359 #endif
1360
1361         if (test_opt(sbi, INLINE_XATTR_SIZE)) {
1362                 int min_size, max_size;
1363
1364                 if (!f2fs_sb_has_extra_attr(sbi) ||
1365                         !f2fs_sb_has_flexible_inline_xattr(sbi)) {
1366                         f2fs_err(sbi, "extra_attr or flexible_inline_xattr feature is off");
1367                         return -EINVAL;
1368                 }
1369                 if (!test_opt(sbi, INLINE_XATTR)) {
1370                         f2fs_err(sbi, "inline_xattr_size option should be set with inline_xattr option");
1371                         return -EINVAL;
1372                 }
1373
1374                 min_size = MIN_INLINE_XATTR_SIZE;
1375                 max_size = MAX_INLINE_XATTR_SIZE;
1376
1377                 if (F2FS_OPTION(sbi).inline_xattr_size < min_size ||
1378                                 F2FS_OPTION(sbi).inline_xattr_size > max_size) {
1379                         f2fs_err(sbi, "inline xattr size is out of range: %d ~ %d",
1380                                  min_size, max_size);
1381                         return -EINVAL;
1382                 }
1383         }
1384
1385         if (test_opt(sbi, ATGC) && f2fs_lfs_mode(sbi)) {
1386                 f2fs_err(sbi, "LFS is not compatible with ATGC");
1387                 return -EINVAL;
1388         }
1389
1390         if (f2fs_is_readonly(sbi) && test_opt(sbi, FLUSH_MERGE)) {
1391                 f2fs_err(sbi, "FLUSH_MERGE not compatible with readonly mode");
1392                 return -EINVAL;
1393         }
1394
1395         if (f2fs_sb_has_readonly(sbi) && !f2fs_readonly(sbi->sb)) {
1396                 f2fs_err(sbi, "Allow to mount readonly mode only");
1397                 return -EROFS;
1398         }
1399         return 0;
1400 }
1401
1402 static struct inode *f2fs_alloc_inode(struct super_block *sb)
1403 {
1404         struct f2fs_inode_info *fi;
1405
1406         if (time_to_inject(F2FS_SB(sb), FAULT_SLAB_ALLOC))
1407                 return NULL;
1408
1409         fi = alloc_inode_sb(sb, f2fs_inode_cachep, GFP_F2FS_ZERO);
1410         if (!fi)
1411                 return NULL;
1412
1413         init_once((void *) fi);
1414
1415         /* Initialize f2fs-specific inode info */
1416         atomic_set(&fi->dirty_pages, 0);
1417         atomic_set(&fi->i_compr_blocks, 0);
1418         init_f2fs_rwsem(&fi->i_sem);
1419         spin_lock_init(&fi->i_size_lock);
1420         INIT_LIST_HEAD(&fi->dirty_list);
1421         INIT_LIST_HEAD(&fi->gdirty_list);
1422         init_f2fs_rwsem(&fi->i_gc_rwsem[READ]);
1423         init_f2fs_rwsem(&fi->i_gc_rwsem[WRITE]);
1424         init_f2fs_rwsem(&fi->i_xattr_sem);
1425
1426         /* Will be used by directory only */
1427         fi->i_dir_level = F2FS_SB(sb)->dir_level;
1428
1429         return &fi->vfs_inode;
1430 }
1431
1432 static int f2fs_drop_inode(struct inode *inode)
1433 {
1434         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1435         int ret;
1436
1437         /*
1438          * during filesystem shutdown, if checkpoint is disabled,
1439          * drop useless meta/node dirty pages.
1440          */
1441         if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
1442                 if (inode->i_ino == F2FS_NODE_INO(sbi) ||
1443                         inode->i_ino == F2FS_META_INO(sbi)) {
1444                         trace_f2fs_drop_inode(inode, 1);
1445                         return 1;
1446                 }
1447         }
1448
1449         /*
1450          * This is to avoid a deadlock condition like below.
1451          * writeback_single_inode(inode)
1452          *  - f2fs_write_data_page
1453          *    - f2fs_gc -> iput -> evict
1454          *       - inode_wait_for_writeback(inode)
1455          */
1456         if ((!inode_unhashed(inode) && inode->i_state & I_SYNC)) {
1457                 if (!inode->i_nlink && !is_bad_inode(inode)) {
1458                         /* to avoid evict_inode call simultaneously */
1459                         atomic_inc(&inode->i_count);
1460                         spin_unlock(&inode->i_lock);
1461
1462                         /* should remain fi->extent_tree for writepage */
1463                         f2fs_destroy_extent_node(inode);
1464
1465                         sb_start_intwrite(inode->i_sb);
1466                         f2fs_i_size_write(inode, 0);
1467
1468                         f2fs_submit_merged_write_cond(F2FS_I_SB(inode),
1469                                         inode, NULL, 0, DATA);
1470                         truncate_inode_pages_final(inode->i_mapping);
1471
1472                         if (F2FS_HAS_BLOCKS(inode))
1473                                 f2fs_truncate(inode);
1474
1475                         sb_end_intwrite(inode->i_sb);
1476
1477                         spin_lock(&inode->i_lock);
1478                         atomic_dec(&inode->i_count);
1479                 }
1480                 trace_f2fs_drop_inode(inode, 0);
1481                 return 0;
1482         }
1483         ret = generic_drop_inode(inode);
1484         if (!ret)
1485                 ret = fscrypt_drop_inode(inode);
1486         trace_f2fs_drop_inode(inode, ret);
1487         return ret;
1488 }
1489
1490 int f2fs_inode_dirtied(struct inode *inode, bool sync)
1491 {
1492         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1493         int ret = 0;
1494
1495         spin_lock(&sbi->inode_lock[DIRTY_META]);
1496         if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
1497                 ret = 1;
1498         } else {
1499                 set_inode_flag(inode, FI_DIRTY_INODE);
1500                 stat_inc_dirty_inode(sbi, DIRTY_META);
1501         }
1502         if (sync && list_empty(&F2FS_I(inode)->gdirty_list)) {
1503                 list_add_tail(&F2FS_I(inode)->gdirty_list,
1504                                 &sbi->inode_list[DIRTY_META]);
1505                 inc_page_count(sbi, F2FS_DIRTY_IMETA);
1506         }
1507         spin_unlock(&sbi->inode_lock[DIRTY_META]);
1508         return ret;
1509 }
1510
1511 void f2fs_inode_synced(struct inode *inode)
1512 {
1513         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1514
1515         spin_lock(&sbi->inode_lock[DIRTY_META]);
1516         if (!is_inode_flag_set(inode, FI_DIRTY_INODE)) {
1517                 spin_unlock(&sbi->inode_lock[DIRTY_META]);
1518                 return;
1519         }
1520         if (!list_empty(&F2FS_I(inode)->gdirty_list)) {
1521                 list_del_init(&F2FS_I(inode)->gdirty_list);
1522                 dec_page_count(sbi, F2FS_DIRTY_IMETA);
1523         }
1524         clear_inode_flag(inode, FI_DIRTY_INODE);
1525         clear_inode_flag(inode, FI_AUTO_RECOVER);
1526         stat_dec_dirty_inode(F2FS_I_SB(inode), DIRTY_META);
1527         spin_unlock(&sbi->inode_lock[DIRTY_META]);
1528 }
1529
1530 /*
1531  * f2fs_dirty_inode() is called from __mark_inode_dirty()
1532  *
1533  * We should call set_dirty_inode to write the dirty inode through write_inode.
1534  */
1535 static void f2fs_dirty_inode(struct inode *inode, int flags)
1536 {
1537         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1538
1539         if (inode->i_ino == F2FS_NODE_INO(sbi) ||
1540                         inode->i_ino == F2FS_META_INO(sbi))
1541                 return;
1542
1543         if (is_inode_flag_set(inode, FI_AUTO_RECOVER))
1544                 clear_inode_flag(inode, FI_AUTO_RECOVER);
1545
1546         f2fs_inode_dirtied(inode, false);
1547 }
1548
1549 static void f2fs_free_inode(struct inode *inode)
1550 {
1551         fscrypt_free_inode(inode);
1552         kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode));
1553 }
1554
1555 static void destroy_percpu_info(struct f2fs_sb_info *sbi)
1556 {
1557         percpu_counter_destroy(&sbi->total_valid_inode_count);
1558         percpu_counter_destroy(&sbi->rf_node_block_count);
1559         percpu_counter_destroy(&sbi->alloc_valid_block_count);
1560 }
1561
1562 static void destroy_device_list(struct f2fs_sb_info *sbi)
1563 {
1564         int i;
1565
1566         for (i = 0; i < sbi->s_ndevs; i++) {
1567                 if (i > 0)
1568                         bdev_fput(FDEV(i).bdev_file);
1569 #ifdef CONFIG_BLK_DEV_ZONED
1570                 kvfree(FDEV(i).blkz_seq);
1571 #endif
1572         }
1573         kvfree(sbi->devs);
1574 }
1575
1576 static void f2fs_put_super(struct super_block *sb)
1577 {
1578         struct f2fs_sb_info *sbi = F2FS_SB(sb);
1579         int i;
1580         int err = 0;
1581         bool done;
1582
1583         /* unregister procfs/sysfs entries in advance to avoid race case */
1584         f2fs_unregister_sysfs(sbi);
1585
1586         f2fs_quota_off_umount(sb);
1587
1588         /* prevent remaining shrinker jobs */
1589         mutex_lock(&sbi->umount_mutex);
1590
1591         /*
1592          * flush all issued checkpoints and stop checkpoint issue thread.
1593          * after then, all checkpoints should be done by each process context.
1594          */
1595         f2fs_stop_ckpt_thread(sbi);
1596
1597         /*
1598          * We don't need to do checkpoint when superblock is clean.
1599          * But, the previous checkpoint was not done by umount, it needs to do
1600          * clean checkpoint again.
1601          */
1602         if ((is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||
1603                         !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG))) {
1604                 struct cp_control cpc = {
1605                         .reason = CP_UMOUNT,
1606                 };
1607                 stat_inc_cp_call_count(sbi, TOTAL_CALL);
1608                 err = f2fs_write_checkpoint(sbi, &cpc);
1609         }
1610
1611         /* be sure to wait for any on-going discard commands */
1612         done = f2fs_issue_discard_timeout(sbi);
1613         if (f2fs_realtime_discard_enable(sbi) && !sbi->discard_blks && done) {
1614                 struct cp_control cpc = {
1615                         .reason = CP_UMOUNT | CP_TRIMMED,
1616                 };
1617                 stat_inc_cp_call_count(sbi, TOTAL_CALL);
1618                 err = f2fs_write_checkpoint(sbi, &cpc);
1619         }
1620
1621         /*
1622          * normally superblock is clean, so we need to release this.
1623          * In addition, EIO will skip do checkpoint, we need this as well.
1624          */
1625         f2fs_release_ino_entry(sbi, true);
1626
1627         f2fs_leave_shrinker(sbi);
1628         mutex_unlock(&sbi->umount_mutex);
1629
1630         /* our cp_error case, we can wait for any writeback page */
1631         f2fs_flush_merged_writes(sbi);
1632
1633         f2fs_wait_on_all_pages(sbi, F2FS_WB_CP_DATA);
1634
1635         if (err || f2fs_cp_error(sbi)) {
1636                 truncate_inode_pages_final(NODE_MAPPING(sbi));
1637                 truncate_inode_pages_final(META_MAPPING(sbi));
1638         }
1639
1640         for (i = 0; i < NR_COUNT_TYPE; i++) {
1641                 if (!get_pages(sbi, i))
1642                         continue;
1643                 f2fs_err(sbi, "detect filesystem reference count leak during "
1644                         "umount, type: %d, count: %lld", i, get_pages(sbi, i));
1645                 f2fs_bug_on(sbi, 1);
1646         }
1647
1648         f2fs_bug_on(sbi, sbi->fsync_node_num);
1649
1650         f2fs_destroy_compress_inode(sbi);
1651
1652         iput(sbi->node_inode);
1653         sbi->node_inode = NULL;
1654
1655         iput(sbi->meta_inode);
1656         sbi->meta_inode = NULL;
1657
1658         /*
1659          * iput() can update stat information, if f2fs_write_checkpoint()
1660          * above failed with error.
1661          */
1662         f2fs_destroy_stats(sbi);
1663
1664         /* destroy f2fs internal modules */
1665         f2fs_destroy_node_manager(sbi);
1666         f2fs_destroy_segment_manager(sbi);
1667
1668         /* flush s_error_work before sbi destroy */
1669         flush_work(&sbi->s_error_work);
1670
1671         f2fs_destroy_post_read_wq(sbi);
1672
1673         kvfree(sbi->ckpt);
1674
1675         if (sbi->s_chksum_driver)
1676                 crypto_free_shash(sbi->s_chksum_driver);
1677         kfree(sbi->raw_super);
1678
1679         f2fs_destroy_page_array_cache(sbi);
1680         f2fs_destroy_xattr_caches(sbi);
1681 #ifdef CONFIG_QUOTA
1682         for (i = 0; i < MAXQUOTAS; i++)
1683                 kfree(F2FS_OPTION(sbi).s_qf_names[i]);
1684 #endif
1685         fscrypt_free_dummy_policy(&F2FS_OPTION(sbi).dummy_enc_policy);
1686         destroy_percpu_info(sbi);
1687         f2fs_destroy_iostat(sbi);
1688         for (i = 0; i < NR_PAGE_TYPE; i++)
1689                 kvfree(sbi->write_io[i]);
1690 #if IS_ENABLED(CONFIG_UNICODE)
1691         utf8_unload(sb->s_encoding);
1692 #endif
1693 }
1694
1695 int f2fs_sync_fs(struct super_block *sb, int sync)
1696 {
1697         struct f2fs_sb_info *sbi = F2FS_SB(sb);
1698         int err = 0;
1699
1700         if (unlikely(f2fs_cp_error(sbi)))
1701                 return 0;
1702         if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
1703                 return 0;
1704
1705         trace_f2fs_sync_fs(sb, sync);
1706
1707         if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
1708                 return -EAGAIN;
1709
1710         if (sync) {
1711                 stat_inc_cp_call_count(sbi, TOTAL_CALL);
1712                 err = f2fs_issue_checkpoint(sbi);
1713         }
1714
1715         return err;
1716 }
1717
1718 static int f2fs_freeze(struct super_block *sb)
1719 {
1720         if (f2fs_readonly(sb))
1721                 return 0;
1722
1723         /* IO error happened before */
1724         if (unlikely(f2fs_cp_error(F2FS_SB(sb))))
1725                 return -EIO;
1726
1727         /* must be clean, since sync_filesystem() was already called */
1728         if (is_sbi_flag_set(F2FS_SB(sb), SBI_IS_DIRTY))
1729                 return -EINVAL;
1730
1731         /* Let's flush checkpoints and stop the thread. */
1732         f2fs_flush_ckpt_thread(F2FS_SB(sb));
1733
1734         /* to avoid deadlock on f2fs_evict_inode->SB_FREEZE_FS */
1735         set_sbi_flag(F2FS_SB(sb), SBI_IS_FREEZING);
1736         return 0;
1737 }
1738
1739 static int f2fs_unfreeze(struct super_block *sb)
1740 {
1741         clear_sbi_flag(F2FS_SB(sb), SBI_IS_FREEZING);
1742         return 0;
1743 }
1744
1745 #ifdef CONFIG_QUOTA
1746 static int f2fs_statfs_project(struct super_block *sb,
1747                                 kprojid_t projid, struct kstatfs *buf)
1748 {
1749         struct kqid qid;
1750         struct dquot *dquot;
1751         u64 limit;
1752         u64 curblock;
1753
1754         qid = make_kqid_projid(projid);
1755         dquot = dqget(sb, qid);
1756         if (IS_ERR(dquot))
1757                 return PTR_ERR(dquot);
1758         spin_lock(&dquot->dq_dqb_lock);
1759
1760         limit = min_not_zero(dquot->dq_dqb.dqb_bsoftlimit,
1761                                         dquot->dq_dqb.dqb_bhardlimit);
1762         if (limit)
1763                 limit >>= sb->s_blocksize_bits;
1764
1765         if (limit && buf->f_blocks > limit) {
1766                 curblock = (dquot->dq_dqb.dqb_curspace +
1767                             dquot->dq_dqb.dqb_rsvspace) >> sb->s_blocksize_bits;
1768                 buf->f_blocks = limit;
1769                 buf->f_bfree = buf->f_bavail =
1770                         (buf->f_blocks > curblock) ?
1771                          (buf->f_blocks - curblock) : 0;
1772         }
1773
1774         limit = min_not_zero(dquot->dq_dqb.dqb_isoftlimit,
1775                                         dquot->dq_dqb.dqb_ihardlimit);
1776
1777         if (limit && buf->f_files > limit) {
1778                 buf->f_files = limit;
1779                 buf->f_ffree =
1780                         (buf->f_files > dquot->dq_dqb.dqb_curinodes) ?
1781                          (buf->f_files - dquot->dq_dqb.dqb_curinodes) : 0;
1782         }
1783
1784         spin_unlock(&dquot->dq_dqb_lock);
1785         dqput(dquot);
1786         return 0;
1787 }
1788 #endif
1789
1790 static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)
1791 {
1792         struct super_block *sb = dentry->d_sb;
1793         struct f2fs_sb_info *sbi = F2FS_SB(sb);
1794         u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
1795         block_t total_count, user_block_count, start_count;
1796         u64 avail_node_count;
1797         unsigned int total_valid_node_count;
1798
1799         total_count = le64_to_cpu(sbi->raw_super->block_count);
1800         start_count = le32_to_cpu(sbi->raw_super->segment0_blkaddr);
1801         buf->f_type = F2FS_SUPER_MAGIC;
1802         buf->f_bsize = sbi->blocksize;
1803
1804         buf->f_blocks = total_count - start_count;
1805
1806         spin_lock(&sbi->stat_lock);
1807
1808         user_block_count = sbi->user_block_count;
1809         total_valid_node_count = valid_node_count(sbi);
1810         avail_node_count = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;
1811         buf->f_bfree = user_block_count - valid_user_blocks(sbi) -
1812                                                 sbi->current_reserved_blocks;
1813
1814         if (unlikely(buf->f_bfree <= sbi->unusable_block_count))
1815                 buf->f_bfree = 0;
1816         else
1817                 buf->f_bfree -= sbi->unusable_block_count;
1818         spin_unlock(&sbi->stat_lock);
1819
1820         if (buf->f_bfree > F2FS_OPTION(sbi).root_reserved_blocks)
1821                 buf->f_bavail = buf->f_bfree -
1822                                 F2FS_OPTION(sbi).root_reserved_blocks;
1823         else
1824                 buf->f_bavail = 0;
1825
1826         if (avail_node_count > user_block_count) {
1827                 buf->f_files = user_block_count;
1828                 buf->f_ffree = buf->f_bavail;
1829         } else {
1830                 buf->f_files = avail_node_count;
1831                 buf->f_ffree = min(avail_node_count - total_valid_node_count,
1832                                         buf->f_bavail);
1833         }
1834
1835         buf->f_namelen = F2FS_NAME_LEN;
1836         buf->f_fsid    = u64_to_fsid(id);
1837
1838 #ifdef CONFIG_QUOTA
1839         if (is_inode_flag_set(dentry->d_inode, FI_PROJ_INHERIT) &&
1840                         sb_has_quota_limits_enabled(sb, PRJQUOTA)) {
1841                 f2fs_statfs_project(sb, F2FS_I(dentry->d_inode)->i_projid, buf);
1842         }
1843 #endif
1844         return 0;
1845 }
1846
1847 static inline void f2fs_show_quota_options(struct seq_file *seq,
1848                                            struct super_block *sb)
1849 {
1850 #ifdef CONFIG_QUOTA
1851         struct f2fs_sb_info *sbi = F2FS_SB(sb);
1852
1853         if (F2FS_OPTION(sbi).s_jquota_fmt) {
1854                 char *fmtname = "";
1855
1856                 switch (F2FS_OPTION(sbi).s_jquota_fmt) {
1857                 case QFMT_VFS_OLD:
1858                         fmtname = "vfsold";
1859                         break;
1860                 case QFMT_VFS_V0:
1861                         fmtname = "vfsv0";
1862                         break;
1863                 case QFMT_VFS_V1:
1864                         fmtname = "vfsv1";
1865                         break;
1866                 }
1867                 seq_printf(seq, ",jqfmt=%s", fmtname);
1868         }
1869
1870         if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA])
1871                 seq_show_option(seq, "usrjquota",
1872                         F2FS_OPTION(sbi).s_qf_names[USRQUOTA]);
1873
1874         if (F2FS_OPTION(sbi).s_qf_names[GRPQUOTA])
1875                 seq_show_option(seq, "grpjquota",
1876                         F2FS_OPTION(sbi).s_qf_names[GRPQUOTA]);
1877
1878         if (F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])
1879                 seq_show_option(seq, "prjjquota",
1880                         F2FS_OPTION(sbi).s_qf_names[PRJQUOTA]);
1881 #endif
1882 }
1883
1884 #ifdef CONFIG_F2FS_FS_COMPRESSION
1885 static inline void f2fs_show_compress_options(struct seq_file *seq,
1886                                                         struct super_block *sb)
1887 {
1888         struct f2fs_sb_info *sbi = F2FS_SB(sb);
1889         char *algtype = "";
1890         int i;
1891
1892         if (!f2fs_sb_has_compression(sbi))
1893                 return;
1894
1895         switch (F2FS_OPTION(sbi).compress_algorithm) {
1896         case COMPRESS_LZO:
1897                 algtype = "lzo";
1898                 break;
1899         case COMPRESS_LZ4:
1900                 algtype = "lz4";
1901                 break;
1902         case COMPRESS_ZSTD:
1903                 algtype = "zstd";
1904                 break;
1905         case COMPRESS_LZORLE:
1906                 algtype = "lzo-rle";
1907                 break;
1908         }
1909         seq_printf(seq, ",compress_algorithm=%s", algtype);
1910
1911         if (F2FS_OPTION(sbi).compress_level)
1912                 seq_printf(seq, ":%d", F2FS_OPTION(sbi).compress_level);
1913
1914         seq_printf(seq, ",compress_log_size=%u",
1915                         F2FS_OPTION(sbi).compress_log_size);
1916
1917         for (i = 0; i < F2FS_OPTION(sbi).compress_ext_cnt; i++) {
1918                 seq_printf(seq, ",compress_extension=%s",
1919                         F2FS_OPTION(sbi).extensions[i]);
1920         }
1921
1922         for (i = 0; i < F2FS_OPTION(sbi).nocompress_ext_cnt; i++) {
1923                 seq_printf(seq, ",nocompress_extension=%s",
1924                         F2FS_OPTION(sbi).noextensions[i]);
1925         }
1926
1927         if (F2FS_OPTION(sbi).compress_chksum)
1928                 seq_puts(seq, ",compress_chksum");
1929
1930         if (F2FS_OPTION(sbi).compress_mode == COMPR_MODE_FS)
1931                 seq_printf(seq, ",compress_mode=%s", "fs");
1932         else if (F2FS_OPTION(sbi).compress_mode == COMPR_MODE_USER)
1933                 seq_printf(seq, ",compress_mode=%s", "user");
1934
1935         if (test_opt(sbi, COMPRESS_CACHE))
1936                 seq_puts(seq, ",compress_cache");
1937 }
1938 #endif
1939
1940 static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
1941 {
1942         struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb);
1943
1944         if (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_SYNC)
1945                 seq_printf(seq, ",background_gc=%s", "sync");
1946         else if (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_ON)
1947                 seq_printf(seq, ",background_gc=%s", "on");
1948         else if (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_OFF)
1949                 seq_printf(seq, ",background_gc=%s", "off");
1950
1951         if (test_opt(sbi, GC_MERGE))
1952                 seq_puts(seq, ",gc_merge");
1953         else
1954                 seq_puts(seq, ",nogc_merge");
1955
1956         if (test_opt(sbi, DISABLE_ROLL_FORWARD))
1957                 seq_puts(seq, ",disable_roll_forward");
1958         if (test_opt(sbi, NORECOVERY))
1959                 seq_puts(seq, ",norecovery");
1960         if (test_opt(sbi, DISCARD)) {
1961                 seq_puts(seq, ",discard");
1962                 if (F2FS_OPTION(sbi).discard_unit == DISCARD_UNIT_BLOCK)
1963                         seq_printf(seq, ",discard_unit=%s", "block");
1964                 else if (F2FS_OPTION(sbi).discard_unit == DISCARD_UNIT_SEGMENT)
1965                         seq_printf(seq, ",discard_unit=%s", "segment");
1966                 else if (F2FS_OPTION(sbi).discard_unit == DISCARD_UNIT_SECTION)
1967                         seq_printf(seq, ",discard_unit=%s", "section");
1968         } else {
1969                 seq_puts(seq, ",nodiscard");
1970         }
1971 #ifdef CONFIG_F2FS_FS_XATTR
1972         if (test_opt(sbi, XATTR_USER))
1973                 seq_puts(seq, ",user_xattr");
1974         else
1975                 seq_puts(seq, ",nouser_xattr");
1976         if (test_opt(sbi, INLINE_XATTR))
1977                 seq_puts(seq, ",inline_xattr");
1978         else
1979                 seq_puts(seq, ",noinline_xattr");
1980         if (test_opt(sbi, INLINE_XATTR_SIZE))
1981                 seq_printf(seq, ",inline_xattr_size=%u",
1982                                         F2FS_OPTION(sbi).inline_xattr_size);
1983 #endif
1984 #ifdef CONFIG_F2FS_FS_POSIX_ACL
1985         if (test_opt(sbi, POSIX_ACL))
1986                 seq_puts(seq, ",acl");
1987         else
1988                 seq_puts(seq, ",noacl");
1989 #endif
1990         if (test_opt(sbi, DISABLE_EXT_IDENTIFY))
1991                 seq_puts(seq, ",disable_ext_identify");
1992         if (test_opt(sbi, INLINE_DATA))
1993                 seq_puts(seq, ",inline_data");
1994         else
1995                 seq_puts(seq, ",noinline_data");
1996         if (test_opt(sbi, INLINE_DENTRY))
1997                 seq_puts(seq, ",inline_dentry");
1998         else
1999                 seq_puts(seq, ",noinline_dentry");
2000         if (test_opt(sbi, FLUSH_MERGE))
2001                 seq_puts(seq, ",flush_merge");
2002         else
2003                 seq_puts(seq, ",noflush_merge");
2004         if (test_opt(sbi, NOBARRIER))
2005                 seq_puts(seq, ",nobarrier");
2006         else
2007                 seq_puts(seq, ",barrier");
2008         if (test_opt(sbi, FASTBOOT))
2009                 seq_puts(seq, ",fastboot");
2010         if (test_opt(sbi, READ_EXTENT_CACHE))
2011                 seq_puts(seq, ",extent_cache");
2012         else
2013                 seq_puts(seq, ",noextent_cache");
2014         if (test_opt(sbi, AGE_EXTENT_CACHE))
2015                 seq_puts(seq, ",age_extent_cache");
2016         if (test_opt(sbi, DATA_FLUSH))
2017                 seq_puts(seq, ",data_flush");
2018
2019         seq_puts(seq, ",mode=");
2020         if (F2FS_OPTION(sbi).fs_mode == FS_MODE_ADAPTIVE)
2021                 seq_puts(seq, "adaptive");
2022         else if (F2FS_OPTION(sbi).fs_mode == FS_MODE_LFS)
2023                 seq_puts(seq, "lfs");
2024         else if (F2FS_OPTION(sbi).fs_mode == FS_MODE_FRAGMENT_SEG)
2025                 seq_puts(seq, "fragment:segment");
2026         else if (F2FS_OPTION(sbi).fs_mode == FS_MODE_FRAGMENT_BLK)
2027                 seq_puts(seq, "fragment:block");
2028         seq_printf(seq, ",active_logs=%u", F2FS_OPTION(sbi).active_logs);
2029         if (test_opt(sbi, RESERVE_ROOT))
2030                 seq_printf(seq, ",reserve_root=%u,resuid=%u,resgid=%u",
2031                                 F2FS_OPTION(sbi).root_reserved_blocks,
2032                                 from_kuid_munged(&init_user_ns,
2033                                         F2FS_OPTION(sbi).s_resuid),
2034                                 from_kgid_munged(&init_user_ns,
2035                                         F2FS_OPTION(sbi).s_resgid));
2036 #ifdef CONFIG_F2FS_FAULT_INJECTION
2037         if (test_opt(sbi, FAULT_INJECTION)) {
2038                 seq_printf(seq, ",fault_injection=%u",
2039                                 F2FS_OPTION(sbi).fault_info.inject_rate);
2040                 seq_printf(seq, ",fault_type=%u",
2041                                 F2FS_OPTION(sbi).fault_info.inject_type);
2042         }
2043 #endif
2044 #ifdef CONFIG_QUOTA
2045         if (test_opt(sbi, QUOTA))
2046                 seq_puts(seq, ",quota");
2047         if (test_opt(sbi, USRQUOTA))
2048                 seq_puts(seq, ",usrquota");
2049         if (test_opt(sbi, GRPQUOTA))
2050                 seq_puts(seq, ",grpquota");
2051         if (test_opt(sbi, PRJQUOTA))
2052                 seq_puts(seq, ",prjquota");
2053 #endif
2054         f2fs_show_quota_options(seq, sbi->sb);
2055
2056         fscrypt_show_test_dummy_encryption(seq, ',', sbi->sb);
2057
2058         if (sbi->sb->s_flags & SB_INLINECRYPT)
2059                 seq_puts(seq, ",inlinecrypt");
2060
2061         if (F2FS_OPTION(sbi).alloc_mode == ALLOC_MODE_DEFAULT)
2062                 seq_printf(seq, ",alloc_mode=%s", "default");
2063         else if (F2FS_OPTION(sbi).alloc_mode == ALLOC_MODE_REUSE)
2064                 seq_printf(seq, ",alloc_mode=%s", "reuse");
2065
2066         if (test_opt(sbi, DISABLE_CHECKPOINT))
2067                 seq_printf(seq, ",checkpoint=disable:%u",
2068                                 F2FS_OPTION(sbi).unusable_cap);
2069         if (test_opt(sbi, MERGE_CHECKPOINT))
2070                 seq_puts(seq, ",checkpoint_merge");
2071         else
2072                 seq_puts(seq, ",nocheckpoint_merge");
2073         if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_POSIX)
2074                 seq_printf(seq, ",fsync_mode=%s", "posix");
2075         else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT)
2076                 seq_printf(seq, ",fsync_mode=%s", "strict");
2077         else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_NOBARRIER)
2078                 seq_printf(seq, ",fsync_mode=%s", "nobarrier");
2079
2080 #ifdef CONFIG_F2FS_FS_COMPRESSION
2081         f2fs_show_compress_options(seq, sbi->sb);
2082 #endif
2083
2084         if (test_opt(sbi, ATGC))
2085                 seq_puts(seq, ",atgc");
2086
2087         if (F2FS_OPTION(sbi).memory_mode == MEMORY_MODE_NORMAL)
2088                 seq_printf(seq, ",memory=%s", "normal");
2089         else if (F2FS_OPTION(sbi).memory_mode == MEMORY_MODE_LOW)
2090                 seq_printf(seq, ",memory=%s", "low");
2091
2092         if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_READONLY)
2093                 seq_printf(seq, ",errors=%s", "remount-ro");
2094         else if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_CONTINUE)
2095                 seq_printf(seq, ",errors=%s", "continue");
2096         else if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_PANIC)
2097                 seq_printf(seq, ",errors=%s", "panic");
2098
2099         return 0;
2100 }
2101
2102 static void default_options(struct f2fs_sb_info *sbi, bool remount)
2103 {
2104         /* init some FS parameters */
2105         if (!remount) {
2106                 set_opt(sbi, READ_EXTENT_CACHE);
2107                 clear_opt(sbi, DISABLE_CHECKPOINT);
2108
2109                 if (f2fs_hw_support_discard(sbi) || f2fs_hw_should_discard(sbi))
2110                         set_opt(sbi, DISCARD);
2111
2112                 if (f2fs_sb_has_blkzoned(sbi))
2113                         F2FS_OPTION(sbi).discard_unit = DISCARD_UNIT_SECTION;
2114                 else
2115                         F2FS_OPTION(sbi).discard_unit = DISCARD_UNIT_BLOCK;
2116         }
2117
2118         if (f2fs_sb_has_readonly(sbi))
2119                 F2FS_OPTION(sbi).active_logs = NR_CURSEG_RO_TYPE;
2120         else
2121                 F2FS_OPTION(sbi).active_logs = NR_CURSEG_PERSIST_TYPE;
2122
2123         F2FS_OPTION(sbi).inline_xattr_size = DEFAULT_INLINE_XATTR_ADDRS;
2124         if (le32_to_cpu(F2FS_RAW_SUPER(sbi)->segment_count_main) <=
2125                                                         SMALL_VOLUME_SEGMENTS)
2126                 F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
2127         else
2128                 F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;
2129         F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;
2130         F2FS_OPTION(sbi).s_resuid = make_kuid(&init_user_ns, F2FS_DEF_RESUID);
2131         F2FS_OPTION(sbi).s_resgid = make_kgid(&init_user_ns, F2FS_DEF_RESGID);
2132         if (f2fs_sb_has_compression(sbi)) {
2133                 F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZ4;
2134                 F2FS_OPTION(sbi).compress_log_size = MIN_COMPRESS_LOG_SIZE;
2135                 F2FS_OPTION(sbi).compress_ext_cnt = 0;
2136                 F2FS_OPTION(sbi).compress_mode = COMPR_MODE_FS;
2137         }
2138         F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ON;
2139         F2FS_OPTION(sbi).memory_mode = MEMORY_MODE_NORMAL;
2140         F2FS_OPTION(sbi).errors = MOUNT_ERRORS_CONTINUE;
2141
2142         set_opt(sbi, INLINE_XATTR);
2143         set_opt(sbi, INLINE_DATA);
2144         set_opt(sbi, INLINE_DENTRY);
2145         set_opt(sbi, MERGE_CHECKPOINT);
2146         F2FS_OPTION(sbi).unusable_cap = 0;
2147         sbi->sb->s_flags |= SB_LAZYTIME;
2148         if (!f2fs_is_readonly(sbi))
2149                 set_opt(sbi, FLUSH_MERGE);
2150         if (f2fs_sb_has_blkzoned(sbi))
2151                 F2FS_OPTION(sbi).fs_mode = FS_MODE_LFS;
2152         else
2153                 F2FS_OPTION(sbi).fs_mode = FS_MODE_ADAPTIVE;
2154
2155 #ifdef CONFIG_F2FS_FS_XATTR
2156         set_opt(sbi, XATTR_USER);
2157 #endif
2158 #ifdef CONFIG_F2FS_FS_POSIX_ACL
2159         set_opt(sbi, POSIX_ACL);
2160 #endif
2161
2162         f2fs_build_fault_attr(sbi, 0, 0);
2163 }
2164
2165 #ifdef CONFIG_QUOTA
2166 static int f2fs_enable_quotas(struct super_block *sb);
2167 #endif
2168
2169 static int f2fs_disable_checkpoint(struct f2fs_sb_info *sbi)
2170 {
2171         unsigned int s_flags = sbi->sb->s_flags;
2172         struct cp_control cpc;
2173         unsigned int gc_mode = sbi->gc_mode;
2174         int err = 0;
2175         int ret;
2176         block_t unusable;
2177
2178         if (s_flags & SB_RDONLY) {
2179                 f2fs_err(sbi, "checkpoint=disable on readonly fs");
2180                 return -EINVAL;
2181         }
2182         sbi->sb->s_flags |= SB_ACTIVE;
2183
2184         /* check if we need more GC first */
2185         unusable = f2fs_get_unusable_blocks(sbi);
2186         if (!f2fs_disable_cp_again(sbi, unusable))
2187                 goto skip_gc;
2188
2189         f2fs_update_time(sbi, DISABLE_TIME);
2190
2191         sbi->gc_mode = GC_URGENT_HIGH;
2192
2193         while (!f2fs_time_over(sbi, DISABLE_TIME)) {
2194                 struct f2fs_gc_control gc_control = {
2195                         .victim_segno = NULL_SEGNO,
2196                         .init_gc_type = FG_GC,
2197                         .should_migrate_blocks = false,
2198                         .err_gc_skipped = true,
2199                         .no_bg_gc = true,
2200                         .nr_free_secs = 1 };
2201
2202                 f2fs_down_write(&sbi->gc_lock);
2203                 stat_inc_gc_call_count(sbi, FOREGROUND);
2204                 err = f2fs_gc(sbi, &gc_control);
2205                 if (err == -ENODATA) {
2206                         err = 0;
2207                         break;
2208                 }
2209                 if (err && err != -EAGAIN)
2210                         break;
2211         }
2212
2213         ret = sync_filesystem(sbi->sb);
2214         if (ret || err) {
2215                 err = ret ? ret : err;
2216                 goto restore_flag;
2217         }
2218
2219         unusable = f2fs_get_unusable_blocks(sbi);
2220         if (f2fs_disable_cp_again(sbi, unusable)) {
2221                 err = -EAGAIN;
2222                 goto restore_flag;
2223         }
2224
2225 skip_gc:
2226         f2fs_down_write(&sbi->gc_lock);
2227         cpc.reason = CP_PAUSE;
2228         set_sbi_flag(sbi, SBI_CP_DISABLED);
2229         stat_inc_cp_call_count(sbi, TOTAL_CALL);
2230         err = f2fs_write_checkpoint(sbi, &cpc);
2231         if (err)
2232                 goto out_unlock;
2233
2234         spin_lock(&sbi->stat_lock);
2235         sbi->unusable_block_count = unusable;
2236         spin_unlock(&sbi->stat_lock);
2237
2238 out_unlock:
2239         f2fs_up_write(&sbi->gc_lock);
2240 restore_flag:
2241         sbi->gc_mode = gc_mode;
2242         sbi->sb->s_flags = s_flags;     /* Restore SB_RDONLY status */
2243         return err;
2244 }
2245
2246 static void f2fs_enable_checkpoint(struct f2fs_sb_info *sbi)
2247 {
2248         int retry = DEFAULT_RETRY_IO_COUNT;
2249
2250         /* we should flush all the data to keep data consistency */
2251         do {
2252                 sync_inodes_sb(sbi->sb);
2253                 f2fs_io_schedule_timeout(DEFAULT_IO_TIMEOUT);
2254         } while (get_pages(sbi, F2FS_DIRTY_DATA) && retry--);
2255
2256         if (unlikely(retry < 0))
2257                 f2fs_warn(sbi, "checkpoint=enable has some unwritten data.");
2258
2259         f2fs_down_write(&sbi->gc_lock);
2260         f2fs_dirty_to_prefree(sbi);
2261
2262         clear_sbi_flag(sbi, SBI_CP_DISABLED);
2263         set_sbi_flag(sbi, SBI_IS_DIRTY);
2264         f2fs_up_write(&sbi->gc_lock);
2265
2266         f2fs_sync_fs(sbi->sb, 1);
2267
2268         /* Let's ensure there's no pending checkpoint anymore */
2269         f2fs_flush_ckpt_thread(sbi);
2270 }
2271
2272 static int f2fs_remount(struct super_block *sb, int *flags, char *data)
2273 {
2274         struct f2fs_sb_info *sbi = F2FS_SB(sb);
2275         struct f2fs_mount_info org_mount_opt;
2276         unsigned long old_sb_flags;
2277         int err;
2278         bool need_restart_gc = false, need_stop_gc = false;
2279         bool need_restart_flush = false, need_stop_flush = false;
2280         bool need_restart_discard = false, need_stop_discard = false;
2281         bool need_enable_checkpoint = false, need_disable_checkpoint = false;
2282         bool no_read_extent_cache = !test_opt(sbi, READ_EXTENT_CACHE);
2283         bool no_age_extent_cache = !test_opt(sbi, AGE_EXTENT_CACHE);
2284         bool enable_checkpoint = !test_opt(sbi, DISABLE_CHECKPOINT);
2285         bool no_atgc = !test_opt(sbi, ATGC);
2286         bool no_discard = !test_opt(sbi, DISCARD);
2287         bool no_compress_cache = !test_opt(sbi, COMPRESS_CACHE);
2288         bool block_unit_discard = f2fs_block_unit_discard(sbi);
2289 #ifdef CONFIG_QUOTA
2290         int i, j;
2291 #endif
2292
2293         /*
2294          * Save the old mount options in case we
2295          * need to restore them.
2296          */
2297         org_mount_opt = sbi->mount_opt;
2298         old_sb_flags = sb->s_flags;
2299
2300 #ifdef CONFIG_QUOTA
2301         org_mount_opt.s_jquota_fmt = F2FS_OPTION(sbi).s_jquota_fmt;
2302         for (i = 0; i < MAXQUOTAS; i++) {
2303                 if (F2FS_OPTION(sbi).s_qf_names[i]) {
2304                         org_mount_opt.s_qf_names[i] =
2305                                 kstrdup(F2FS_OPTION(sbi).s_qf_names[i],
2306                                 GFP_KERNEL);
2307                         if (!org_mount_opt.s_qf_names[i]) {
2308                                 for (j = 0; j < i; j++)
2309                                         kfree(org_mount_opt.s_qf_names[j]);
2310                                 return -ENOMEM;
2311                         }
2312                 } else {
2313                         org_mount_opt.s_qf_names[i] = NULL;
2314                 }
2315         }
2316 #endif
2317
2318         /* recover superblocks we couldn't write due to previous RO mount */
2319         if (!(*flags & SB_RDONLY) && is_sbi_flag_set(sbi, SBI_NEED_SB_WRITE)) {
2320                 err = f2fs_commit_super(sbi, false);
2321                 f2fs_info(sbi, "Try to recover all the superblocks, ret: %d",
2322                           err);
2323                 if (!err)
2324                         clear_sbi_flag(sbi, SBI_NEED_SB_WRITE);
2325         }
2326
2327         default_options(sbi, true);
2328
2329         /* parse mount options */
2330         err = parse_options(sb, data, true);
2331         if (err)
2332                 goto restore_opts;
2333
2334 #ifdef CONFIG_BLK_DEV_ZONED
2335         if (f2fs_sb_has_blkzoned(sbi) &&
2336                 sbi->max_open_zones < F2FS_OPTION(sbi).active_logs) {
2337                 f2fs_err(sbi,
2338                         "zoned: max open zones %u is too small, need at least %u open zones",
2339                                  sbi->max_open_zones, F2FS_OPTION(sbi).active_logs);
2340                 err = -EINVAL;
2341                 goto restore_opts;
2342         }
2343 #endif
2344
2345         /* flush outstanding errors before changing fs state */
2346         flush_work(&sbi->s_error_work);
2347
2348         /*
2349          * Previous and new state of filesystem is RO,
2350          * so skip checking GC and FLUSH_MERGE conditions.
2351          */
2352         if (f2fs_readonly(sb) && (*flags & SB_RDONLY))
2353                 goto skip;
2354
2355         if (f2fs_dev_is_readonly(sbi) && !(*flags & SB_RDONLY)) {
2356                 err = -EROFS;
2357                 goto restore_opts;
2358         }
2359
2360 #ifdef CONFIG_QUOTA
2361         if (!f2fs_readonly(sb) && (*flags & SB_RDONLY)) {
2362                 err = dquot_suspend(sb, -1);
2363                 if (err < 0)
2364                         goto restore_opts;
2365         } else if (f2fs_readonly(sb) && !(*flags & SB_RDONLY)) {
2366                 /* dquot_resume needs RW */
2367                 sb->s_flags &= ~SB_RDONLY;
2368                 if (sb_any_quota_suspended(sb)) {
2369                         dquot_resume(sb, -1);
2370                 } else if (f2fs_sb_has_quota_ino(sbi)) {
2371                         err = f2fs_enable_quotas(sb);
2372                         if (err)
2373                                 goto restore_opts;
2374                 }
2375         }
2376 #endif
2377         if (f2fs_lfs_mode(sbi) && !IS_F2FS_IPU_DISABLE(sbi)) {
2378                 err = -EINVAL;
2379                 f2fs_warn(sbi, "LFS is not compatible with IPU");
2380                 goto restore_opts;
2381         }
2382
2383         /* disallow enable atgc dynamically */
2384         if (no_atgc == !!test_opt(sbi, ATGC)) {
2385                 err = -EINVAL;
2386                 f2fs_warn(sbi, "switch atgc option is not allowed");
2387                 goto restore_opts;
2388         }
2389
2390         /* disallow enable/disable extent_cache dynamically */
2391         if (no_read_extent_cache == !!test_opt(sbi, READ_EXTENT_CACHE)) {
2392                 err = -EINVAL;
2393                 f2fs_warn(sbi, "switch extent_cache option is not allowed");
2394                 goto restore_opts;
2395         }
2396         /* disallow enable/disable age extent_cache dynamically */
2397         if (no_age_extent_cache == !!test_opt(sbi, AGE_EXTENT_CACHE)) {
2398                 err = -EINVAL;
2399                 f2fs_warn(sbi, "switch age_extent_cache option is not allowed");
2400                 goto restore_opts;
2401         }
2402
2403         if (no_compress_cache == !!test_opt(sbi, COMPRESS_CACHE)) {
2404                 err = -EINVAL;
2405                 f2fs_warn(sbi, "switch compress_cache option is not allowed");
2406                 goto restore_opts;
2407         }
2408
2409         if (block_unit_discard != f2fs_block_unit_discard(sbi)) {
2410                 err = -EINVAL;
2411                 f2fs_warn(sbi, "switch discard_unit option is not allowed");
2412                 goto restore_opts;
2413         }
2414
2415         if ((*flags & SB_RDONLY) && test_opt(sbi, DISABLE_CHECKPOINT)) {
2416                 err = -EINVAL;
2417                 f2fs_warn(sbi, "disabling checkpoint not compatible with read-only");
2418                 goto restore_opts;
2419         }
2420
2421         /*
2422          * We stop the GC thread if FS is mounted as RO
2423          * or if background_gc = off is passed in mount
2424          * option. Also sync the filesystem.
2425          */
2426         if ((*flags & SB_RDONLY) ||
2427                         (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_OFF &&
2428                         !test_opt(sbi, GC_MERGE))) {
2429                 if (sbi->gc_thread) {
2430                         f2fs_stop_gc_thread(sbi);
2431                         need_restart_gc = true;
2432                 }
2433         } else if (!sbi->gc_thread) {
2434                 err = f2fs_start_gc_thread(sbi);
2435                 if (err)
2436                         goto restore_opts;
2437                 need_stop_gc = true;
2438         }
2439
2440         if (*flags & SB_RDONLY) {
2441                 sync_inodes_sb(sb);
2442
2443                 set_sbi_flag(sbi, SBI_IS_DIRTY);
2444                 set_sbi_flag(sbi, SBI_IS_CLOSE);
2445                 f2fs_sync_fs(sb, 1);
2446                 clear_sbi_flag(sbi, SBI_IS_CLOSE);
2447         }
2448
2449         /*
2450          * We stop issue flush thread if FS is mounted as RO
2451          * or if flush_merge is not passed in mount option.
2452          */
2453         if ((*flags & SB_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {
2454                 clear_opt(sbi, FLUSH_MERGE);
2455                 f2fs_destroy_flush_cmd_control(sbi, false);
2456                 need_restart_flush = true;
2457         } else {
2458                 err = f2fs_create_flush_cmd_control(sbi);
2459                 if (err)
2460                         goto restore_gc;
2461                 need_stop_flush = true;
2462         }
2463
2464         if (no_discard == !!test_opt(sbi, DISCARD)) {
2465                 if (test_opt(sbi, DISCARD)) {
2466                         err = f2fs_start_discard_thread(sbi);
2467                         if (err)
2468                                 goto restore_flush;
2469                         need_stop_discard = true;
2470                 } else {
2471                         f2fs_stop_discard_thread(sbi);
2472                         f2fs_issue_discard_timeout(sbi);
2473                         need_restart_discard = true;
2474                 }
2475         }
2476
2477         if (enable_checkpoint == !!test_opt(sbi, DISABLE_CHECKPOINT)) {
2478                 if (test_opt(sbi, DISABLE_CHECKPOINT)) {
2479                         err = f2fs_disable_checkpoint(sbi);
2480                         if (err)
2481                                 goto restore_discard;
2482                         need_enable_checkpoint = true;
2483                 } else {
2484                         f2fs_enable_checkpoint(sbi);
2485                         need_disable_checkpoint = true;
2486                 }
2487         }
2488
2489         /*
2490          * Place this routine at the end, since a new checkpoint would be
2491          * triggered while remount and we need to take care of it before
2492          * returning from remount.
2493          */
2494         if ((*flags & SB_RDONLY) || test_opt(sbi, DISABLE_CHECKPOINT) ||
2495                         !test_opt(sbi, MERGE_CHECKPOINT)) {
2496                 f2fs_stop_ckpt_thread(sbi);
2497         } else {
2498                 /* Flush if the prevous checkpoint, if exists. */
2499                 f2fs_flush_ckpt_thread(sbi);
2500
2501                 err = f2fs_start_ckpt_thread(sbi);
2502                 if (err) {
2503                         f2fs_err(sbi,
2504                             "Failed to start F2FS issue_checkpoint_thread (%d)",
2505                             err);
2506                         goto restore_checkpoint;
2507                 }
2508         }
2509
2510 skip:
2511 #ifdef CONFIG_QUOTA
2512         /* Release old quota file names */
2513         for (i = 0; i < MAXQUOTAS; i++)
2514                 kfree(org_mount_opt.s_qf_names[i]);
2515 #endif
2516         /* Update the POSIXACL Flag */
2517         sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
2518                 (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
2519
2520         limit_reserve_root(sbi);
2521         adjust_unusable_cap_perc(sbi);
2522         *flags = (*flags & ~SB_LAZYTIME) | (sb->s_flags & SB_LAZYTIME);
2523         return 0;
2524 restore_checkpoint:
2525         if (need_enable_checkpoint) {
2526                 f2fs_enable_checkpoint(sbi);
2527         } else if (need_disable_checkpoint) {
2528                 if (f2fs_disable_checkpoint(sbi))
2529                         f2fs_warn(sbi, "checkpoint has not been disabled");
2530         }
2531 restore_discard:
2532         if (need_restart_discard) {
2533                 if (f2fs_start_discard_thread(sbi))
2534                         f2fs_warn(sbi, "discard has been stopped");
2535         } else if (need_stop_discard) {
2536                 f2fs_stop_discard_thread(sbi);
2537         }
2538 restore_flush:
2539         if (need_restart_flush) {
2540                 if (f2fs_create_flush_cmd_control(sbi))
2541                         f2fs_warn(sbi, "background flush thread has stopped");
2542         } else if (need_stop_flush) {
2543                 clear_opt(sbi, FLUSH_MERGE);
2544                 f2fs_destroy_flush_cmd_control(sbi, false);
2545         }
2546 restore_gc:
2547         if (need_restart_gc) {
2548                 if (f2fs_start_gc_thread(sbi))
2549                         f2fs_warn(sbi, "background gc thread has stopped");
2550         } else if (need_stop_gc) {
2551                 f2fs_stop_gc_thread(sbi);
2552         }
2553 restore_opts:
2554 #ifdef CONFIG_QUOTA
2555         F2FS_OPTION(sbi).s_jquota_fmt = org_mount_opt.s_jquota_fmt;
2556         for (i = 0; i < MAXQUOTAS; i++) {
2557                 kfree(F2FS_OPTION(sbi).s_qf_names[i]);
2558                 F2FS_OPTION(sbi).s_qf_names[i] = org_mount_opt.s_qf_names[i];
2559         }
2560 #endif
2561         sbi->mount_opt = org_mount_opt;
2562         sb->s_flags = old_sb_flags;
2563         return err;
2564 }
2565
2566 static void f2fs_shutdown(struct super_block *sb)
2567 {
2568         f2fs_do_shutdown(F2FS_SB(sb), F2FS_GOING_DOWN_NOSYNC, false, false);
2569 }
2570
2571 #ifdef CONFIG_QUOTA
2572 static bool f2fs_need_recovery(struct f2fs_sb_info *sbi)
2573 {
2574         /* need to recovery orphan */
2575         if (is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG))
2576                 return true;
2577         /* need to recovery data */
2578         if (test_opt(sbi, DISABLE_ROLL_FORWARD))
2579                 return false;
2580         if (test_opt(sbi, NORECOVERY))
2581                 return false;
2582         return !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG);
2583 }
2584
2585 static bool f2fs_recover_quota_begin(struct f2fs_sb_info *sbi)
2586 {
2587         bool readonly = f2fs_readonly(sbi->sb);
2588
2589         if (!f2fs_need_recovery(sbi))
2590                 return false;
2591
2592         /* it doesn't need to check f2fs_sb_has_readonly() */
2593         if (f2fs_hw_is_readonly(sbi))
2594                 return false;
2595
2596         if (readonly) {
2597                 sbi->sb->s_flags &= ~SB_RDONLY;
2598                 set_sbi_flag(sbi, SBI_IS_WRITABLE);
2599         }
2600
2601         /*
2602          * Turn on quotas which were not enabled for read-only mounts if
2603          * filesystem has quota feature, so that they are updated correctly.
2604          */
2605         return f2fs_enable_quota_files(sbi, readonly);
2606 }
2607
2608 static void f2fs_recover_quota_end(struct f2fs_sb_info *sbi,
2609                                                 bool quota_enabled)
2610 {
2611         if (quota_enabled)
2612                 f2fs_quota_off_umount(sbi->sb);
2613
2614         if (is_sbi_flag_set(sbi, SBI_IS_WRITABLE)) {
2615                 clear_sbi_flag(sbi, SBI_IS_WRITABLE);
2616                 sbi->sb->s_flags |= SB_RDONLY;
2617         }
2618 }
2619
2620 /* Read data from quotafile */
2621 static ssize_t f2fs_quota_read(struct super_block *sb, int type, char *data,
2622                                size_t len, loff_t off)
2623 {
2624         struct inode *inode = sb_dqopt(sb)->files[type];
2625         struct address_space *mapping = inode->i_mapping;
2626         block_t blkidx = F2FS_BYTES_TO_BLK(off);
2627         int offset = off & (sb->s_blocksize - 1);
2628         int tocopy;
2629         size_t toread;
2630         loff_t i_size = i_size_read(inode);
2631         struct page *page;
2632
2633         if (off > i_size)
2634                 return 0;
2635
2636         if (off + len > i_size)
2637                 len = i_size - off;
2638         toread = len;
2639         while (toread > 0) {
2640                 tocopy = min_t(unsigned long, sb->s_blocksize - offset, toread);
2641 repeat:
2642                 page = read_cache_page_gfp(mapping, blkidx, GFP_NOFS);
2643                 if (IS_ERR(page)) {
2644                         if (PTR_ERR(page) == -ENOMEM) {
2645                                 memalloc_retry_wait(GFP_NOFS);
2646                                 goto repeat;
2647                         }
2648                         set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
2649                         return PTR_ERR(page);
2650                 }
2651
2652                 lock_page(page);
2653
2654                 if (unlikely(page->mapping != mapping)) {
2655                         f2fs_put_page(page, 1);
2656                         goto repeat;
2657                 }
2658                 if (unlikely(!PageUptodate(page))) {
2659                         f2fs_put_page(page, 1);
2660                         set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
2661                         return -EIO;
2662                 }
2663
2664                 memcpy_from_page(data, page, offset, tocopy);
2665                 f2fs_put_page(page, 1);
2666
2667                 offset = 0;
2668                 toread -= tocopy;
2669                 data += tocopy;
2670                 blkidx++;
2671         }
2672         return len;
2673 }
2674
2675 /* Write to quotafile */
2676 static ssize_t f2fs_quota_write(struct super_block *sb, int type,
2677                                 const char *data, size_t len, loff_t off)
2678 {
2679         struct inode *inode = sb_dqopt(sb)->files[type];
2680         struct address_space *mapping = inode->i_mapping;
2681         const struct address_space_operations *a_ops = mapping->a_ops;
2682         int offset = off & (sb->s_blocksize - 1);
2683         size_t towrite = len;
2684         struct folio *folio;
2685         void *fsdata = NULL;
2686         int err = 0;
2687         int tocopy;
2688
2689         while (towrite > 0) {
2690                 tocopy = min_t(unsigned long, sb->s_blocksize - offset,
2691                                                                 towrite);
2692 retry:
2693                 err = a_ops->write_begin(NULL, mapping, off, tocopy,
2694                                                         &folio, &fsdata);
2695                 if (unlikely(err)) {
2696                         if (err == -ENOMEM) {
2697                                 f2fs_io_schedule_timeout(DEFAULT_IO_TIMEOUT);
2698                                 goto retry;
2699                         }
2700                         set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
2701                         break;
2702                 }
2703
2704                 memcpy_to_folio(folio, offset_in_folio(folio, off), data, tocopy);
2705
2706                 a_ops->write_end(NULL, mapping, off, tocopy, tocopy,
2707                                                 folio, fsdata);
2708                 offset = 0;
2709                 towrite -= tocopy;
2710                 off += tocopy;
2711                 data += tocopy;
2712                 cond_resched();
2713         }
2714
2715         if (len == towrite)
2716                 return err;
2717         inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
2718         f2fs_mark_inode_dirty_sync(inode, false);
2719         return len - towrite;
2720 }
2721
2722 int f2fs_dquot_initialize(struct inode *inode)
2723 {
2724         if (time_to_inject(F2FS_I_SB(inode), FAULT_DQUOT_INIT))
2725                 return -ESRCH;
2726
2727         return dquot_initialize(inode);
2728 }
2729
2730 static struct dquot __rcu **f2fs_get_dquots(struct inode *inode)
2731 {
2732         return F2FS_I(inode)->i_dquot;
2733 }
2734
2735 static qsize_t *f2fs_get_reserved_space(struct inode *inode)
2736 {
2737         return &F2FS_I(inode)->i_reserved_quota;
2738 }
2739
2740 static int f2fs_quota_on_mount(struct f2fs_sb_info *sbi, int type)
2741 {
2742         if (is_set_ckpt_flags(sbi, CP_QUOTA_NEED_FSCK_FLAG)) {
2743                 f2fs_err(sbi, "quota sysfile may be corrupted, skip loading it");
2744                 return 0;
2745         }
2746
2747         return dquot_quota_on_mount(sbi->sb, F2FS_OPTION(sbi).s_qf_names[type],
2748                                         F2FS_OPTION(sbi).s_jquota_fmt, type);
2749 }
2750
2751 int f2fs_enable_quota_files(struct f2fs_sb_info *sbi, bool rdonly)
2752 {
2753         int enabled = 0;
2754         int i, err;
2755
2756         if (f2fs_sb_has_quota_ino(sbi) && rdonly) {
2757                 err = f2fs_enable_quotas(sbi->sb);
2758                 if (err) {
2759                         f2fs_err(sbi, "Cannot turn on quota_ino: %d", err);
2760                         return 0;
2761                 }
2762                 return 1;
2763         }
2764
2765         for (i = 0; i < MAXQUOTAS; i++) {
2766                 if (F2FS_OPTION(sbi).s_qf_names[i]) {
2767                         err = f2fs_quota_on_mount(sbi, i);
2768                         if (!err) {
2769                                 enabled = 1;
2770                                 continue;
2771                         }
2772                         f2fs_err(sbi, "Cannot turn on quotas: %d on %d",
2773                                  err, i);
2774                 }
2775         }
2776         return enabled;
2777 }
2778
2779 static int f2fs_quota_enable(struct super_block *sb, int type, int format_id,
2780                              unsigned int flags)
2781 {
2782         struct inode *qf_inode;
2783         unsigned long qf_inum;
2784         unsigned long qf_flag = F2FS_QUOTA_DEFAULT_FL;
2785         int err;
2786
2787         BUG_ON(!f2fs_sb_has_quota_ino(F2FS_SB(sb)));
2788
2789         qf_inum = f2fs_qf_ino(sb, type);
2790         if (!qf_inum)
2791                 return -EPERM;
2792
2793         qf_inode = f2fs_iget(sb, qf_inum);
2794         if (IS_ERR(qf_inode)) {
2795                 f2fs_err(F2FS_SB(sb), "Bad quota inode %u:%lu", type, qf_inum);
2796                 return PTR_ERR(qf_inode);
2797         }
2798
2799         /* Don't account quota for quota files to avoid recursion */
2800         inode_lock(qf_inode);
2801         qf_inode->i_flags |= S_NOQUOTA;
2802
2803         if ((F2FS_I(qf_inode)->i_flags & qf_flag) != qf_flag) {
2804                 F2FS_I(qf_inode)->i_flags |= qf_flag;
2805                 f2fs_set_inode_flags(qf_inode);
2806         }
2807         inode_unlock(qf_inode);
2808
2809         err = dquot_load_quota_inode(qf_inode, type, format_id, flags);
2810         iput(qf_inode);
2811         return err;
2812 }
2813
2814 static int f2fs_enable_quotas(struct super_block *sb)
2815 {
2816         struct f2fs_sb_info *sbi = F2FS_SB(sb);
2817         int type, err = 0;
2818         unsigned long qf_inum;
2819         bool quota_mopt[MAXQUOTAS] = {
2820                 test_opt(sbi, USRQUOTA),
2821                 test_opt(sbi, GRPQUOTA),
2822                 test_opt(sbi, PRJQUOTA),
2823         };
2824
2825         if (is_set_ckpt_flags(F2FS_SB(sb), CP_QUOTA_NEED_FSCK_FLAG)) {
2826                 f2fs_err(sbi, "quota file may be corrupted, skip loading it");
2827                 return 0;
2828         }
2829
2830         sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE;
2831
2832         for (type = 0; type < MAXQUOTAS; type++) {
2833                 qf_inum = f2fs_qf_ino(sb, type);
2834                 if (qf_inum) {
2835                         err = f2fs_quota_enable(sb, type, QFMT_VFS_V1,
2836                                 DQUOT_USAGE_ENABLED |
2837                                 (quota_mopt[type] ? DQUOT_LIMITS_ENABLED : 0));
2838                         if (err) {
2839                                 f2fs_err(sbi, "Failed to enable quota tracking (type=%d, err=%d). Please run fsck to fix.",
2840                                          type, err);
2841                                 for (type--; type >= 0; type--)
2842                                         dquot_quota_off(sb, type);
2843                                 set_sbi_flag(F2FS_SB(sb),
2844                                                 SBI_QUOTA_NEED_REPAIR);
2845                                 return err;
2846                         }
2847                 }
2848         }
2849         return 0;
2850 }
2851
2852 static int f2fs_quota_sync_file(struct f2fs_sb_info *sbi, int type)
2853 {
2854         struct quota_info *dqopt = sb_dqopt(sbi->sb);
2855         struct address_space *mapping = dqopt->files[type]->i_mapping;
2856         int ret = 0;
2857
2858         ret = dquot_writeback_dquots(sbi->sb, type);
2859         if (ret)
2860                 goto out;
2861
2862         ret = filemap_fdatawrite(mapping);
2863         if (ret)
2864                 goto out;
2865
2866         /* if we are using journalled quota */
2867         if (is_journalled_quota(sbi))
2868                 goto out;
2869
2870         ret = filemap_fdatawait(mapping);
2871
2872         truncate_inode_pages(&dqopt->files[type]->i_data, 0);
2873 out:
2874         if (ret)
2875                 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
2876         return ret;
2877 }
2878
2879 int f2fs_quota_sync(struct super_block *sb, int type)
2880 {
2881         struct f2fs_sb_info *sbi = F2FS_SB(sb);
2882         struct quota_info *dqopt = sb_dqopt(sb);
2883         int cnt;
2884         int ret = 0;
2885
2886         /*
2887          * Now when everything is written we can discard the pagecache so
2888          * that userspace sees the changes.
2889          */
2890         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2891
2892                 if (type != -1 && cnt != type)
2893                         continue;
2894
2895                 if (!sb_has_quota_active(sb, cnt))
2896                         continue;
2897
2898                 if (!f2fs_sb_has_quota_ino(sbi))
2899                         inode_lock(dqopt->files[cnt]);
2900
2901                 /*
2902                  * do_quotactl
2903                  *  f2fs_quota_sync
2904                  *  f2fs_down_read(quota_sem)
2905                  *  dquot_writeback_dquots()
2906                  *  f2fs_dquot_commit
2907                  *                            block_operation
2908                  *                            f2fs_down_read(quota_sem)
2909                  */
2910                 f2fs_lock_op(sbi);
2911                 f2fs_down_read(&sbi->quota_sem);
2912
2913                 ret = f2fs_quota_sync_file(sbi, cnt);
2914
2915                 f2fs_up_read(&sbi->quota_sem);
2916                 f2fs_unlock_op(sbi);
2917
2918                 if (!f2fs_sb_has_quota_ino(sbi))
2919                         inode_unlock(dqopt->files[cnt]);
2920
2921                 if (ret)
2922                         break;
2923         }
2924         return ret;
2925 }
2926
2927 static int f2fs_quota_on(struct super_block *sb, int type, int format_id,
2928                                                         const struct path *path)
2929 {
2930         struct inode *inode;
2931         int err;
2932
2933         /* if quota sysfile exists, deny enabling quota with specific file */
2934         if (f2fs_sb_has_quota_ino(F2FS_SB(sb))) {
2935                 f2fs_err(F2FS_SB(sb), "quota sysfile already exists");
2936                 return -EBUSY;
2937         }
2938
2939         if (path->dentry->d_sb != sb)
2940                 return -EXDEV;
2941
2942         err = f2fs_quota_sync(sb, type);
2943         if (err)
2944                 return err;
2945
2946         inode = d_inode(path->dentry);
2947
2948         err = filemap_fdatawrite(inode->i_mapping);
2949         if (err)
2950                 return err;
2951
2952         err = filemap_fdatawait(inode->i_mapping);
2953         if (err)
2954                 return err;
2955
2956         err = dquot_quota_on(sb, type, format_id, path);
2957         if (err)
2958                 return err;
2959
2960         inode_lock(inode);
2961         F2FS_I(inode)->i_flags |= F2FS_QUOTA_DEFAULT_FL;
2962         f2fs_set_inode_flags(inode);
2963         inode_unlock(inode);
2964         f2fs_mark_inode_dirty_sync(inode, false);
2965
2966         return 0;
2967 }
2968
2969 static int __f2fs_quota_off(struct super_block *sb, int type)
2970 {
2971         struct inode *inode = sb_dqopt(sb)->files[type];
2972         int err;
2973
2974         if (!inode || !igrab(inode))
2975                 return dquot_quota_off(sb, type);
2976
2977         err = f2fs_quota_sync(sb, type);
2978         if (err)
2979                 goto out_put;
2980
2981         err = dquot_quota_off(sb, type);
2982         if (err || f2fs_sb_has_quota_ino(F2FS_SB(sb)))
2983                 goto out_put;
2984
2985         inode_lock(inode);
2986         F2FS_I(inode)->i_flags &= ~F2FS_QUOTA_DEFAULT_FL;
2987         f2fs_set_inode_flags(inode);
2988         inode_unlock(inode);
2989         f2fs_mark_inode_dirty_sync(inode, false);
2990 out_put:
2991         iput(inode);
2992         return err;
2993 }
2994
2995 static int f2fs_quota_off(struct super_block *sb, int type)
2996 {
2997         struct f2fs_sb_info *sbi = F2FS_SB(sb);
2998         int err;
2999
3000         err = __f2fs_quota_off(sb, type);
3001
3002         /*
3003          * quotactl can shutdown journalled quota, result in inconsistence
3004          * between quota record and fs data by following updates, tag the
3005          * flag to let fsck be aware of it.
3006          */
3007         if (is_journalled_quota(sbi))
3008                 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
3009         return err;
3010 }
3011
3012 void f2fs_quota_off_umount(struct super_block *sb)
3013 {
3014         int type;
3015         int err;
3016
3017         for (type = 0; type < MAXQUOTAS; type++) {
3018                 err = __f2fs_quota_off(sb, type);
3019                 if (err) {
3020                         int ret = dquot_quota_off(sb, type);
3021
3022                         f2fs_err(F2FS_SB(sb), "Fail to turn off disk quota (type: %d, err: %d, ret:%d), Please run fsck to fix it.",
3023                                  type, err, ret);
3024                         set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
3025                 }
3026         }
3027         /*
3028          * In case of checkpoint=disable, we must flush quota blocks.
3029          * This can cause NULL exception for node_inode in end_io, since
3030          * put_super already dropped it.
3031          */
3032         sync_filesystem(sb);
3033 }
3034
3035 static void f2fs_truncate_quota_inode_pages(struct super_block *sb)
3036 {
3037         struct quota_info *dqopt = sb_dqopt(sb);
3038         int type;
3039
3040         for (type = 0; type < MAXQUOTAS; type++) {
3041                 if (!dqopt->files[type])
3042                         continue;
3043                 f2fs_inode_synced(dqopt->files[type]);
3044         }
3045 }
3046
3047 static int f2fs_dquot_commit(struct dquot *dquot)
3048 {
3049         struct f2fs_sb_info *sbi = F2FS_SB(dquot->dq_sb);
3050         int ret;
3051
3052         f2fs_down_read_nested(&sbi->quota_sem, SINGLE_DEPTH_NESTING);
3053         ret = dquot_commit(dquot);
3054         if (ret < 0)
3055                 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
3056         f2fs_up_read(&sbi->quota_sem);
3057         return ret;
3058 }
3059
3060 static int f2fs_dquot_acquire(struct dquot *dquot)
3061 {
3062         struct f2fs_sb_info *sbi = F2FS_SB(dquot->dq_sb);
3063         int ret;
3064
3065         f2fs_down_read(&sbi->quota_sem);
3066         ret = dquot_acquire(dquot);
3067         if (ret < 0)
3068                 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
3069         f2fs_up_read(&sbi->quota_sem);
3070         return ret;
3071 }
3072
3073 static int f2fs_dquot_release(struct dquot *dquot)
3074 {
3075         struct f2fs_sb_info *sbi = F2FS_SB(dquot->dq_sb);
3076         int ret = dquot_release(dquot);
3077
3078         if (ret < 0)
3079                 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
3080         return ret;
3081 }
3082
3083 static int f2fs_dquot_mark_dquot_dirty(struct dquot *dquot)
3084 {
3085         struct super_block *sb = dquot->dq_sb;
3086         struct f2fs_sb_info *sbi = F2FS_SB(sb);
3087         int ret = dquot_mark_dquot_dirty(dquot);
3088
3089         /* if we are using journalled quota */
3090         if (is_journalled_quota(sbi))
3091                 set_sbi_flag(sbi, SBI_QUOTA_NEED_FLUSH);
3092
3093         return ret;
3094 }
3095
3096 static int f2fs_dquot_commit_info(struct super_block *sb, int type)
3097 {
3098         struct f2fs_sb_info *sbi = F2FS_SB(sb);
3099         int ret = dquot_commit_info(sb, type);
3100
3101         if (ret < 0)
3102                 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
3103         return ret;
3104 }
3105
3106 static int f2fs_get_projid(struct inode *inode, kprojid_t *projid)
3107 {
3108         *projid = F2FS_I(inode)->i_projid;
3109         return 0;
3110 }
3111
3112 static const struct dquot_operations f2fs_quota_operations = {
3113         .get_reserved_space = f2fs_get_reserved_space,
3114         .write_dquot    = f2fs_dquot_commit,
3115         .acquire_dquot  = f2fs_dquot_acquire,
3116         .release_dquot  = f2fs_dquot_release,
3117         .mark_dirty     = f2fs_dquot_mark_dquot_dirty,
3118         .write_info     = f2fs_dquot_commit_info,
3119         .alloc_dquot    = dquot_alloc,
3120         .destroy_dquot  = dquot_destroy,
3121         .get_projid     = f2fs_get_projid,
3122         .get_next_id    = dquot_get_next_id,
3123 };
3124
3125 static const struct quotactl_ops f2fs_quotactl_ops = {
3126         .quota_on       = f2fs_quota_on,
3127         .quota_off      = f2fs_quota_off,
3128         .quota_sync     = f2fs_quota_sync,
3129         .get_state      = dquot_get_state,
3130         .set_info       = dquot_set_dqinfo,
3131         .get_dqblk      = dquot_get_dqblk,
3132         .set_dqblk      = dquot_set_dqblk,
3133         .get_nextdqblk  = dquot_get_next_dqblk,
3134 };
3135 #else
3136 int f2fs_dquot_initialize(struct inode *inode)
3137 {
3138         return 0;
3139 }
3140
3141 int f2fs_quota_sync(struct super_block *sb, int type)
3142 {
3143         return 0;
3144 }
3145
3146 void f2fs_quota_off_umount(struct super_block *sb)
3147 {
3148 }
3149 #endif
3150
3151 static const struct super_operations f2fs_sops = {
3152         .alloc_inode    = f2fs_alloc_inode,
3153         .free_inode     = f2fs_free_inode,
3154         .drop_inode     = f2fs_drop_inode,
3155         .write_inode    = f2fs_write_inode,
3156         .dirty_inode    = f2fs_dirty_inode,
3157         .show_options   = f2fs_show_options,
3158 #ifdef CONFIG_QUOTA
3159         .quota_read     = f2fs_quota_read,
3160         .quota_write    = f2fs_quota_write,
3161         .get_dquots     = f2fs_get_dquots,
3162 #endif
3163         .evict_inode    = f2fs_evict_inode,
3164         .put_super      = f2fs_put_super,
3165         .sync_fs        = f2fs_sync_fs,
3166         .freeze_fs      = f2fs_freeze,
3167         .unfreeze_fs    = f2fs_unfreeze,
3168         .statfs         = f2fs_statfs,
3169         .remount_fs     = f2fs_remount,
3170         .shutdown       = f2fs_shutdown,
3171 };
3172
3173 #ifdef CONFIG_FS_ENCRYPTION
3174 static int f2fs_get_context(struct inode *inode, void *ctx, size_t len)
3175 {
3176         return f2fs_getxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,
3177                                 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,
3178                                 ctx, len, NULL);
3179 }
3180
3181 static int f2fs_set_context(struct inode *inode, const void *ctx, size_t len,
3182                                                         void *fs_data)
3183 {
3184         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3185
3186         /*
3187          * Encrypting the root directory is not allowed because fsck
3188          * expects lost+found directory to exist and remain unencrypted
3189          * if LOST_FOUND feature is enabled.
3190          *
3191          */
3192         if (f2fs_sb_has_lost_found(sbi) &&
3193                         inode->i_ino == F2FS_ROOT_INO(sbi))
3194                 return -EPERM;
3195
3196         return f2fs_setxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,
3197                                 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,
3198                                 ctx, len, fs_data, XATTR_CREATE);
3199 }
3200
3201 static const union fscrypt_policy *f2fs_get_dummy_policy(struct super_block *sb)
3202 {
3203         return F2FS_OPTION(F2FS_SB(sb)).dummy_enc_policy.policy;
3204 }
3205
3206 static bool f2fs_has_stable_inodes(struct super_block *sb)
3207 {
3208         return true;
3209 }
3210
3211 static struct block_device **f2fs_get_devices(struct super_block *sb,
3212                                               unsigned int *num_devs)
3213 {
3214         struct f2fs_sb_info *sbi = F2FS_SB(sb);
3215         struct block_device **devs;
3216         int i;
3217
3218         if (!f2fs_is_multi_device(sbi))
3219                 return NULL;
3220
3221         devs = kmalloc_array(sbi->s_ndevs, sizeof(*devs), GFP_KERNEL);
3222         if (!devs)
3223                 return ERR_PTR(-ENOMEM);
3224
3225         for (i = 0; i < sbi->s_ndevs; i++)
3226                 devs[i] = FDEV(i).bdev;
3227         *num_devs = sbi->s_ndevs;
3228         return devs;
3229 }
3230
3231 static const struct fscrypt_operations f2fs_cryptops = {
3232         .needs_bounce_pages     = 1,
3233         .has_32bit_inodes       = 1,
3234         .supports_subblock_data_units = 1,
3235         .legacy_key_prefix      = "f2fs:",
3236         .get_context            = f2fs_get_context,
3237         .set_context            = f2fs_set_context,
3238         .get_dummy_policy       = f2fs_get_dummy_policy,
3239         .empty_dir              = f2fs_empty_dir,
3240         .has_stable_inodes      = f2fs_has_stable_inodes,
3241         .get_devices            = f2fs_get_devices,
3242 };
3243 #endif
3244
3245 static struct inode *f2fs_nfs_get_inode(struct super_block *sb,
3246                 u64 ino, u32 generation)
3247 {
3248         struct f2fs_sb_info *sbi = F2FS_SB(sb);
3249         struct inode *inode;
3250
3251         if (f2fs_check_nid_range(sbi, ino))
3252                 return ERR_PTR(-ESTALE);
3253
3254         /*
3255          * f2fs_iget isn't quite right if the inode is currently unallocated!
3256          * However f2fs_iget currently does appropriate checks to handle stale
3257          * inodes so everything is OK.
3258          */
3259         inode = f2fs_iget(sb, ino);
3260         if (IS_ERR(inode))
3261                 return ERR_CAST(inode);
3262         if (unlikely(generation && inode->i_generation != generation)) {
3263                 /* we didn't find the right inode.. */
3264                 iput(inode);
3265                 return ERR_PTR(-ESTALE);
3266         }
3267         return inode;
3268 }
3269
3270 static struct dentry *f2fs_fh_to_dentry(struct super_block *sb, struct fid *fid,
3271                 int fh_len, int fh_type)
3272 {
3273         return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
3274                                     f2fs_nfs_get_inode);
3275 }
3276
3277 static struct dentry *f2fs_fh_to_parent(struct super_block *sb, struct fid *fid,
3278                 int fh_len, int fh_type)
3279 {
3280         return generic_fh_to_parent(sb, fid, fh_len, fh_type,
3281                                     f2fs_nfs_get_inode);
3282 }
3283
3284 static const struct export_operations f2fs_export_ops = {
3285         .encode_fh = generic_encode_ino32_fh,
3286         .fh_to_dentry = f2fs_fh_to_dentry,
3287         .fh_to_parent = f2fs_fh_to_parent,
3288         .get_parent = f2fs_get_parent,
3289 };
3290
3291 loff_t max_file_blocks(struct inode *inode)
3292 {
3293         loff_t result = 0;
3294         loff_t leaf_count;
3295
3296         /*
3297          * note: previously, result is equal to (DEF_ADDRS_PER_INODE -
3298          * DEFAULT_INLINE_XATTR_ADDRS), but now f2fs try to reserve more
3299          * space in inode.i_addr, it will be more safe to reassign
3300          * result as zero.
3301          */
3302
3303         if (inode && f2fs_compressed_file(inode))
3304                 leaf_count = ADDRS_PER_BLOCK(inode);
3305         else
3306                 leaf_count = DEF_ADDRS_PER_BLOCK;
3307
3308         /* two direct node blocks */
3309         result += (leaf_count * 2);
3310
3311         /* two indirect node blocks */
3312         leaf_count *= NIDS_PER_BLOCK;
3313         result += (leaf_count * 2);
3314
3315         /* one double indirect node block */
3316         leaf_count *= NIDS_PER_BLOCK;
3317         result += leaf_count;
3318
3319         /*
3320          * For compatibility with FSCRYPT_POLICY_FLAG_IV_INO_LBLK_{64,32} with
3321          * a 4K crypto data unit, we must restrict the max filesize to what can
3322          * fit within U32_MAX + 1 data units.
3323          */
3324
3325         result = min(result, F2FS_BYTES_TO_BLK(((loff_t)U32_MAX + 1) * 4096));
3326
3327         return result;
3328 }
3329
3330 static int __f2fs_commit_super(struct f2fs_sb_info *sbi, struct folio *folio,
3331                                                 pgoff_t index, bool update)
3332 {
3333         struct bio *bio;
3334         /* it's rare case, we can do fua all the time */
3335         blk_opf_t opf = REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH | REQ_FUA;
3336         int ret;
3337
3338         folio_lock(folio);
3339         folio_wait_writeback(folio);
3340         if (update)
3341                 memcpy(F2FS_SUPER_BLOCK(folio, index), F2FS_RAW_SUPER(sbi),
3342                                         sizeof(struct f2fs_super_block));
3343         folio_mark_dirty(folio);
3344         folio_clear_dirty_for_io(folio);
3345         folio_start_writeback(folio);
3346         folio_unlock(folio);
3347
3348         bio = bio_alloc(sbi->sb->s_bdev, 1, opf, GFP_NOFS);
3349
3350         /* it doesn't need to set crypto context for superblock update */
3351         bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(folio_index(folio));
3352
3353         if (!bio_add_folio(bio, folio, folio_size(folio), 0))
3354                 f2fs_bug_on(sbi, 1);
3355
3356         ret = submit_bio_wait(bio);
3357         folio_end_writeback(folio);
3358
3359         return ret;
3360 }
3361
3362 static inline bool sanity_check_area_boundary(struct f2fs_sb_info *sbi,
3363                                         struct folio *folio, pgoff_t index)
3364 {
3365         struct f2fs_super_block *raw_super = F2FS_SUPER_BLOCK(folio, index);
3366         struct super_block *sb = sbi->sb;
3367         u32 segment0_blkaddr = le32_to_cpu(raw_super->segment0_blkaddr);
3368         u32 cp_blkaddr = le32_to_cpu(raw_super->cp_blkaddr);
3369         u32 sit_blkaddr = le32_to_cpu(raw_super->sit_blkaddr);
3370         u32 nat_blkaddr = le32_to_cpu(raw_super->nat_blkaddr);
3371         u32 ssa_blkaddr = le32_to_cpu(raw_super->ssa_blkaddr);
3372         u32 main_blkaddr = le32_to_cpu(raw_super->main_blkaddr);
3373         u32 segment_count_ckpt = le32_to_cpu(raw_super->segment_count_ckpt);
3374         u32 segment_count_sit = le32_to_cpu(raw_super->segment_count_sit);
3375         u32 segment_count_nat = le32_to_cpu(raw_super->segment_count_nat);
3376         u32 segment_count_ssa = le32_to_cpu(raw_super->segment_count_ssa);
3377         u32 segment_count_main = le32_to_cpu(raw_super->segment_count_main);
3378         u32 segment_count = le32_to_cpu(raw_super->segment_count);
3379         u32 log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
3380         u64 main_end_blkaddr = main_blkaddr +
3381                                 ((u64)segment_count_main << log_blocks_per_seg);
3382         u64 seg_end_blkaddr = segment0_blkaddr +
3383                                 ((u64)segment_count << log_blocks_per_seg);
3384
3385         if (segment0_blkaddr != cp_blkaddr) {
3386                 f2fs_info(sbi, "Mismatch start address, segment0(%u) cp_blkaddr(%u)",
3387                           segment0_blkaddr, cp_blkaddr);
3388                 return true;
3389         }
3390
3391         if (cp_blkaddr + (segment_count_ckpt << log_blocks_per_seg) !=
3392                                                         sit_blkaddr) {
3393                 f2fs_info(sbi, "Wrong CP boundary, start(%u) end(%u) blocks(%u)",
3394                           cp_blkaddr, sit_blkaddr,
3395                           segment_count_ckpt << log_blocks_per_seg);
3396                 return true;
3397         }
3398
3399         if (sit_blkaddr + (segment_count_sit << log_blocks_per_seg) !=
3400                                                         nat_blkaddr) {
3401                 f2fs_info(sbi, "Wrong SIT boundary, start(%u) end(%u) blocks(%u)",
3402                           sit_blkaddr, nat_blkaddr,
3403                           segment_count_sit << log_blocks_per_seg);
3404                 return true;
3405         }
3406
3407         if (nat_blkaddr + (segment_count_nat << log_blocks_per_seg) !=
3408                                                         ssa_blkaddr) {
3409                 f2fs_info(sbi, "Wrong NAT boundary, start(%u) end(%u) blocks(%u)",
3410                           nat_blkaddr, ssa_blkaddr,
3411                           segment_count_nat << log_blocks_per_seg);
3412                 return true;
3413         }
3414
3415         if (ssa_blkaddr + (segment_count_ssa << log_blocks_per_seg) !=
3416                                                         main_blkaddr) {
3417                 f2fs_info(sbi, "Wrong SSA boundary, start(%u) end(%u) blocks(%u)",
3418                           ssa_blkaddr, main_blkaddr,
3419                           segment_count_ssa << log_blocks_per_seg);
3420                 return true;
3421         }
3422
3423         if (main_end_blkaddr > seg_end_blkaddr) {
3424                 f2fs_info(sbi, "Wrong MAIN_AREA boundary, start(%u) end(%llu) block(%u)",
3425                           main_blkaddr, seg_end_blkaddr,
3426                           segment_count_main << log_blocks_per_seg);
3427                 return true;
3428         } else if (main_end_blkaddr < seg_end_blkaddr) {
3429                 int err = 0;
3430                 char *res;
3431
3432                 /* fix in-memory information all the time */
3433                 raw_super->segment_count = cpu_to_le32((main_end_blkaddr -
3434                                 segment0_blkaddr) >> log_blocks_per_seg);
3435
3436                 if (f2fs_readonly(sb) || f2fs_hw_is_readonly(sbi)) {
3437                         set_sbi_flag(sbi, SBI_NEED_SB_WRITE);
3438                         res = "internally";
3439                 } else {
3440                         err = __f2fs_commit_super(sbi, folio, index, false);
3441                         res = err ? "failed" : "done";
3442                 }
3443                 f2fs_info(sbi, "Fix alignment : %s, start(%u) end(%llu) block(%u)",
3444                           res, main_blkaddr, seg_end_blkaddr,
3445                           segment_count_main << log_blocks_per_seg);
3446                 if (err)
3447                         return true;
3448         }
3449         return false;
3450 }
3451
3452 static int sanity_check_raw_super(struct f2fs_sb_info *sbi,
3453                                         struct folio *folio, pgoff_t index)
3454 {
3455         block_t segment_count, segs_per_sec, secs_per_zone, segment_count_main;
3456         block_t total_sections, blocks_per_seg;
3457         struct f2fs_super_block *raw_super = F2FS_SUPER_BLOCK(folio, index);
3458         size_t crc_offset = 0;
3459         __u32 crc = 0;
3460
3461         if (le32_to_cpu(raw_super->magic) != F2FS_SUPER_MAGIC) {
3462                 f2fs_info(sbi, "Magic Mismatch, valid(0x%x) - read(0x%x)",
3463                           F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic));
3464                 return -EINVAL;
3465         }
3466
3467         /* Check checksum_offset and crc in superblock */
3468         if (__F2FS_HAS_FEATURE(raw_super, F2FS_FEATURE_SB_CHKSUM)) {
3469                 crc_offset = le32_to_cpu(raw_super->checksum_offset);
3470                 if (crc_offset !=
3471                         offsetof(struct f2fs_super_block, crc)) {
3472                         f2fs_info(sbi, "Invalid SB checksum offset: %zu",
3473                                   crc_offset);
3474                         return -EFSCORRUPTED;
3475                 }
3476                 crc = le32_to_cpu(raw_super->crc);
3477                 if (!f2fs_crc_valid(sbi, crc, raw_super, crc_offset)) {
3478                         f2fs_info(sbi, "Invalid SB checksum value: %u", crc);
3479                         return -EFSCORRUPTED;
3480                 }
3481         }
3482
3483         /* only support block_size equals to PAGE_SIZE */
3484         if (le32_to_cpu(raw_super->log_blocksize) != F2FS_BLKSIZE_BITS) {
3485                 f2fs_info(sbi, "Invalid log_blocksize (%u), supports only %u",
3486                           le32_to_cpu(raw_super->log_blocksize),
3487                           F2FS_BLKSIZE_BITS);
3488                 return -EFSCORRUPTED;
3489         }
3490
3491         /* check log blocks per segment */
3492         if (le32_to_cpu(raw_super->log_blocks_per_seg) != 9) {
3493                 f2fs_info(sbi, "Invalid log blocks per segment (%u)",
3494                           le32_to_cpu(raw_super->log_blocks_per_seg));
3495                 return -EFSCORRUPTED;
3496         }
3497
3498         /* Currently, support 512/1024/2048/4096/16K bytes sector size */
3499         if (le32_to_cpu(raw_super->log_sectorsize) >
3500                                 F2FS_MAX_LOG_SECTOR_SIZE ||
3501                 le32_to_cpu(raw_super->log_sectorsize) <
3502                                 F2FS_MIN_LOG_SECTOR_SIZE) {
3503                 f2fs_info(sbi, "Invalid log sectorsize (%u)",
3504                           le32_to_cpu(raw_super->log_sectorsize));
3505                 return -EFSCORRUPTED;
3506         }
3507         if (le32_to_cpu(raw_super->log_sectors_per_block) +
3508                 le32_to_cpu(raw_super->log_sectorsize) !=
3509                         F2FS_MAX_LOG_SECTOR_SIZE) {
3510                 f2fs_info(sbi, "Invalid log sectors per block(%u) log sectorsize(%u)",
3511                           le32_to_cpu(raw_super->log_sectors_per_block),
3512                           le32_to_cpu(raw_super->log_sectorsize));
3513                 return -EFSCORRUPTED;
3514         }
3515
3516         segment_count = le32_to_cpu(raw_super->segment_count);
3517         segment_count_main = le32_to_cpu(raw_super->segment_count_main);
3518         segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
3519         secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
3520         total_sections = le32_to_cpu(raw_super->section_count);
3521
3522         /* blocks_per_seg should be 512, given the above check */
3523         blocks_per_seg = BIT(le32_to_cpu(raw_super->log_blocks_per_seg));
3524
3525         if (segment_count > F2FS_MAX_SEGMENT ||
3526                                 segment_count < F2FS_MIN_SEGMENTS) {
3527                 f2fs_info(sbi, "Invalid segment count (%u)", segment_count);
3528                 return -EFSCORRUPTED;
3529         }
3530
3531         if (total_sections > segment_count_main || total_sections < 1 ||
3532                         segs_per_sec > segment_count || !segs_per_sec) {
3533                 f2fs_info(sbi, "Invalid segment/section count (%u, %u x %u)",
3534                           segment_count, total_sections, segs_per_sec);
3535                 return -EFSCORRUPTED;
3536         }
3537
3538         if (segment_count_main != total_sections * segs_per_sec) {
3539                 f2fs_info(sbi, "Invalid segment/section count (%u != %u * %u)",
3540                           segment_count_main, total_sections, segs_per_sec);
3541                 return -EFSCORRUPTED;
3542         }
3543
3544         if ((segment_count / segs_per_sec) < total_sections) {
3545                 f2fs_info(sbi, "Small segment_count (%u < %u * %u)",
3546                           segment_count, segs_per_sec, total_sections);
3547                 return -EFSCORRUPTED;
3548         }
3549
3550         if (segment_count > (le64_to_cpu(raw_super->block_count) >> 9)) {
3551                 f2fs_info(sbi, "Wrong segment_count / block_count (%u > %llu)",
3552                           segment_count, le64_to_cpu(raw_super->block_count));
3553                 return -EFSCORRUPTED;
3554         }
3555
3556         if (RDEV(0).path[0]) {
3557                 block_t dev_seg_count = le32_to_cpu(RDEV(0).total_segments);
3558                 int i = 1;
3559
3560                 while (i < MAX_DEVICES && RDEV(i).path[0]) {
3561                         dev_seg_count += le32_to_cpu(RDEV(i).total_segments);
3562                         i++;
3563                 }
3564                 if (segment_count != dev_seg_count) {
3565                         f2fs_info(sbi, "Segment count (%u) mismatch with total segments from devices (%u)",
3566                                         segment_count, dev_seg_count);
3567                         return -EFSCORRUPTED;
3568                 }
3569         } else {
3570                 if (__F2FS_HAS_FEATURE(raw_super, F2FS_FEATURE_BLKZONED) &&
3571                                         !bdev_is_zoned(sbi->sb->s_bdev)) {
3572                         f2fs_info(sbi, "Zoned block device path is missing");
3573                         return -EFSCORRUPTED;
3574                 }
3575         }
3576
3577         if (secs_per_zone > total_sections || !secs_per_zone) {
3578                 f2fs_info(sbi, "Wrong secs_per_zone / total_sections (%u, %u)",
3579                           secs_per_zone, total_sections);
3580                 return -EFSCORRUPTED;
3581         }
3582         if (le32_to_cpu(raw_super->extension_count) > F2FS_MAX_EXTENSION ||
3583                         raw_super->hot_ext_count > F2FS_MAX_EXTENSION ||
3584                         (le32_to_cpu(raw_super->extension_count) +
3585                         raw_super->hot_ext_count) > F2FS_MAX_EXTENSION) {
3586                 f2fs_info(sbi, "Corrupted extension count (%u + %u > %u)",
3587                           le32_to_cpu(raw_super->extension_count),
3588                           raw_super->hot_ext_count,
3589                           F2FS_MAX_EXTENSION);
3590                 return -EFSCORRUPTED;
3591         }
3592
3593         if (le32_to_cpu(raw_super->cp_payload) >=
3594                                 (blocks_per_seg - F2FS_CP_PACKS -
3595                                 NR_CURSEG_PERSIST_TYPE)) {
3596                 f2fs_info(sbi, "Insane cp_payload (%u >= %u)",
3597                           le32_to_cpu(raw_super->cp_payload),
3598                           blocks_per_seg - F2FS_CP_PACKS -
3599                           NR_CURSEG_PERSIST_TYPE);
3600                 return -EFSCORRUPTED;
3601         }
3602
3603         /* check reserved ino info */
3604         if (le32_to_cpu(raw_super->node_ino) != 1 ||
3605                 le32_to_cpu(raw_super->meta_ino) != 2 ||
3606                 le32_to_cpu(raw_super->root_ino) != 3) {
3607                 f2fs_info(sbi, "Invalid Fs Meta Ino: node(%u) meta(%u) root(%u)",
3608                           le32_to_cpu(raw_super->node_ino),
3609                           le32_to_cpu(raw_super->meta_ino),
3610                           le32_to_cpu(raw_super->root_ino));
3611                 return -EFSCORRUPTED;
3612         }
3613
3614         /* check CP/SIT/NAT/SSA/MAIN_AREA area boundary */
3615         if (sanity_check_area_boundary(sbi, folio, index))
3616                 return -EFSCORRUPTED;
3617
3618         return 0;
3619 }
3620
3621 int f2fs_sanity_check_ckpt(struct f2fs_sb_info *sbi)
3622 {
3623         unsigned int total, fsmeta;
3624         struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
3625         struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
3626         unsigned int ovp_segments, reserved_segments;
3627         unsigned int main_segs, blocks_per_seg;
3628         unsigned int sit_segs, nat_segs;
3629         unsigned int sit_bitmap_size, nat_bitmap_size;
3630         unsigned int log_blocks_per_seg;
3631         unsigned int segment_count_main;
3632         unsigned int cp_pack_start_sum, cp_payload;
3633         block_t user_block_count, valid_user_blocks;
3634         block_t avail_node_count, valid_node_count;
3635         unsigned int nat_blocks, nat_bits_bytes, nat_bits_blocks;
3636         int i, j;
3637
3638         total = le32_to_cpu(raw_super->segment_count);
3639         fsmeta = le32_to_cpu(raw_super->segment_count_ckpt);
3640         sit_segs = le32_to_cpu(raw_super->segment_count_sit);
3641         fsmeta += sit_segs;
3642         nat_segs = le32_to_cpu(raw_super->segment_count_nat);
3643         fsmeta += nat_segs;
3644         fsmeta += le32_to_cpu(ckpt->rsvd_segment_count);
3645         fsmeta += le32_to_cpu(raw_super->segment_count_ssa);
3646
3647         if (unlikely(fsmeta >= total))
3648                 return 1;
3649
3650         ovp_segments = le32_to_cpu(ckpt->overprov_segment_count);
3651         reserved_segments = le32_to_cpu(ckpt->rsvd_segment_count);
3652
3653         if (!f2fs_sb_has_readonly(sbi) &&
3654                         unlikely(fsmeta < F2FS_MIN_META_SEGMENTS ||
3655                         ovp_segments == 0 || reserved_segments == 0)) {
3656                 f2fs_err(sbi, "Wrong layout: check mkfs.f2fs version");
3657                 return 1;
3658         }
3659         user_block_count = le64_to_cpu(ckpt->user_block_count);
3660         segment_count_main = le32_to_cpu(raw_super->segment_count_main) +
3661                         (f2fs_sb_has_readonly(sbi) ? 1 : 0);
3662         log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
3663         if (!user_block_count || user_block_count >=
3664                         segment_count_main << log_blocks_per_seg) {
3665                 f2fs_err(sbi, "Wrong user_block_count: %u",
3666                          user_block_count);
3667                 return 1;
3668         }
3669
3670         valid_user_blocks = le64_to_cpu(ckpt->valid_block_count);
3671         if (valid_user_blocks > user_block_count) {
3672                 f2fs_err(sbi, "Wrong valid_user_blocks: %u, user_block_count: %u",
3673                          valid_user_blocks, user_block_count);
3674                 return 1;
3675         }
3676
3677         valid_node_count = le32_to_cpu(ckpt->valid_node_count);
3678         avail_node_count = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;
3679         if (valid_node_count > avail_node_count) {
3680                 f2fs_err(sbi, "Wrong valid_node_count: %u, avail_node_count: %u",
3681                          valid_node_count, avail_node_count);
3682                 return 1;
3683         }
3684
3685         main_segs = le32_to_cpu(raw_super->segment_count_main);
3686         blocks_per_seg = BLKS_PER_SEG(sbi);
3687
3688         for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
3689                 if (le32_to_cpu(ckpt->cur_node_segno[i]) >= main_segs ||
3690                         le16_to_cpu(ckpt->cur_node_blkoff[i]) >= blocks_per_seg)
3691                         return 1;
3692
3693                 if (f2fs_sb_has_readonly(sbi))
3694                         goto check_data;
3695
3696                 for (j = i + 1; j < NR_CURSEG_NODE_TYPE; j++) {
3697                         if (le32_to_cpu(ckpt->cur_node_segno[i]) ==
3698                                 le32_to_cpu(ckpt->cur_node_segno[j])) {
3699                                 f2fs_err(sbi, "Node segment (%u, %u) has the same segno: %u",
3700                                          i, j,
3701                                          le32_to_cpu(ckpt->cur_node_segno[i]));
3702                                 return 1;
3703                         }
3704                 }
3705         }
3706 check_data:
3707         for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) {
3708                 if (le32_to_cpu(ckpt->cur_data_segno[i]) >= main_segs ||
3709                         le16_to_cpu(ckpt->cur_data_blkoff[i]) >= blocks_per_seg)
3710                         return 1;
3711
3712                 if (f2fs_sb_has_readonly(sbi))
3713                         goto skip_cross;
3714
3715                 for (j = i + 1; j < NR_CURSEG_DATA_TYPE; j++) {
3716                         if (le32_to_cpu(ckpt->cur_data_segno[i]) ==
3717                                 le32_to_cpu(ckpt->cur_data_segno[j])) {
3718                                 f2fs_err(sbi, "Data segment (%u, %u) has the same segno: %u",
3719                                          i, j,
3720                                          le32_to_cpu(ckpt->cur_data_segno[i]));
3721                                 return 1;
3722                         }
3723                 }
3724         }
3725         for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
3726                 for (j = 0; j < NR_CURSEG_DATA_TYPE; j++) {
3727                         if (le32_to_cpu(ckpt->cur_node_segno[i]) ==
3728                                 le32_to_cpu(ckpt->cur_data_segno[j])) {
3729                                 f2fs_err(sbi, "Node segment (%u) and Data segment (%u) has the same segno: %u",
3730                                          i, j,
3731                                          le32_to_cpu(ckpt->cur_node_segno[i]));
3732                                 return 1;
3733                         }
3734                 }
3735         }
3736 skip_cross:
3737         sit_bitmap_size = le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);
3738         nat_bitmap_size = le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);
3739
3740         if (sit_bitmap_size != ((sit_segs / 2) << log_blocks_per_seg) / 8 ||
3741                 nat_bitmap_size != ((nat_segs / 2) << log_blocks_per_seg) / 8) {
3742                 f2fs_err(sbi, "Wrong bitmap size: sit: %u, nat:%u",
3743                          sit_bitmap_size, nat_bitmap_size);
3744                 return 1;
3745         }
3746
3747         cp_pack_start_sum = __start_sum_addr(sbi);
3748         cp_payload = __cp_payload(sbi);
3749         if (cp_pack_start_sum < cp_payload + 1 ||
3750                 cp_pack_start_sum > blocks_per_seg - 1 -
3751                         NR_CURSEG_PERSIST_TYPE) {
3752                 f2fs_err(sbi, "Wrong cp_pack_start_sum: %u",
3753                          cp_pack_start_sum);
3754                 return 1;
3755         }
3756
3757         if (__is_set_ckpt_flags(ckpt, CP_LARGE_NAT_BITMAP_FLAG) &&
3758                 le32_to_cpu(ckpt->checksum_offset) != CP_MIN_CHKSUM_OFFSET) {
3759                 f2fs_warn(sbi, "using deprecated layout of large_nat_bitmap, "
3760                           "please run fsck v1.13.0 or higher to repair, chksum_offset: %u, "
3761                           "fixed with patch: \"f2fs-tools: relocate chksum_offset for large_nat_bitmap feature\"",
3762                           le32_to_cpu(ckpt->checksum_offset));
3763                 return 1;
3764         }
3765
3766         nat_blocks = nat_segs << log_blocks_per_seg;
3767         nat_bits_bytes = nat_blocks / BITS_PER_BYTE;
3768         nat_bits_blocks = F2FS_BLK_ALIGN((nat_bits_bytes << 1) + 8);
3769         if (__is_set_ckpt_flags(ckpt, CP_NAT_BITS_FLAG) &&
3770                 (cp_payload + F2FS_CP_PACKS +
3771                 NR_CURSEG_PERSIST_TYPE + nat_bits_blocks >= blocks_per_seg)) {
3772                 f2fs_warn(sbi, "Insane cp_payload: %u, nat_bits_blocks: %u)",
3773                           cp_payload, nat_bits_blocks);
3774                 return 1;
3775         }
3776
3777         if (unlikely(f2fs_cp_error(sbi))) {
3778                 f2fs_err(sbi, "A bug case: need to run fsck");
3779                 return 1;
3780         }
3781         return 0;
3782 }
3783
3784 static void init_sb_info(struct f2fs_sb_info *sbi)
3785 {
3786         struct f2fs_super_block *raw_super = sbi->raw_super;
3787         int i;
3788
3789         sbi->log_sectors_per_block =
3790                 le32_to_cpu(raw_super->log_sectors_per_block);
3791         sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize);
3792         sbi->blocksize = BIT(sbi->log_blocksize);
3793         sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
3794         sbi->blocks_per_seg = BIT(sbi->log_blocks_per_seg);
3795         sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
3796         sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
3797         sbi->total_sections = le32_to_cpu(raw_super->section_count);
3798         sbi->total_node_count = SEGS_TO_BLKS(sbi,
3799                         ((le32_to_cpu(raw_super->segment_count_nat) / 2) *
3800                         NAT_ENTRY_PER_BLOCK));
3801         F2FS_ROOT_INO(sbi) = le32_to_cpu(raw_super->root_ino);
3802         F2FS_NODE_INO(sbi) = le32_to_cpu(raw_super->node_ino);
3803         F2FS_META_INO(sbi) = le32_to_cpu(raw_super->meta_ino);
3804         sbi->cur_victim_sec = NULL_SECNO;
3805         sbi->gc_mode = GC_NORMAL;
3806         sbi->next_victim_seg[BG_GC] = NULL_SEGNO;
3807         sbi->next_victim_seg[FG_GC] = NULL_SEGNO;
3808         sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH;
3809         sbi->migration_granularity = SEGS_PER_SEC(sbi);
3810         sbi->migration_window_granularity = f2fs_sb_has_blkzoned(sbi) ?
3811                 DEF_MIGRATION_WINDOW_GRANULARITY_ZONED : SEGS_PER_SEC(sbi);
3812         sbi->seq_file_ra_mul = MIN_RA_MUL;
3813         sbi->max_fragment_chunk = DEF_FRAGMENT_SIZE;
3814         sbi->max_fragment_hole = DEF_FRAGMENT_SIZE;
3815         spin_lock_init(&sbi->gc_remaining_trials_lock);
3816         atomic64_set(&sbi->current_atomic_write, 0);
3817
3818         sbi->dir_level = DEF_DIR_LEVEL;
3819         sbi->interval_time[CP_TIME] = DEF_CP_INTERVAL;
3820         sbi->interval_time[REQ_TIME] = DEF_IDLE_INTERVAL;
3821         sbi->interval_time[DISCARD_TIME] = DEF_IDLE_INTERVAL;
3822         sbi->interval_time[GC_TIME] = DEF_IDLE_INTERVAL;
3823         sbi->interval_time[DISABLE_TIME] = DEF_DISABLE_INTERVAL;
3824         sbi->interval_time[UMOUNT_DISCARD_TIMEOUT] =
3825                                 DEF_UMOUNT_DISCARD_TIMEOUT;
3826         clear_sbi_flag(sbi, SBI_NEED_FSCK);
3827
3828         for (i = 0; i < NR_COUNT_TYPE; i++)
3829                 atomic_set(&sbi->nr_pages[i], 0);
3830
3831         for (i = 0; i < META; i++)
3832                 atomic_set(&sbi->wb_sync_req[i], 0);
3833
3834         INIT_LIST_HEAD(&sbi->s_list);
3835         mutex_init(&sbi->umount_mutex);
3836         init_f2fs_rwsem(&sbi->io_order_lock);
3837         spin_lock_init(&sbi->cp_lock);
3838
3839         sbi->dirty_device = 0;
3840         spin_lock_init(&sbi->dev_lock);
3841
3842         init_f2fs_rwsem(&sbi->sb_lock);
3843         init_f2fs_rwsem(&sbi->pin_sem);
3844 }
3845
3846 static int init_percpu_info(struct f2fs_sb_info *sbi)
3847 {
3848         int err;
3849
3850         err = percpu_counter_init(&sbi->alloc_valid_block_count, 0, GFP_KERNEL);
3851         if (err)
3852                 return err;
3853
3854         err = percpu_counter_init(&sbi->rf_node_block_count, 0, GFP_KERNEL);
3855         if (err)
3856                 goto err_valid_block;
3857
3858         err = percpu_counter_init(&sbi->total_valid_inode_count, 0,
3859                                                                 GFP_KERNEL);
3860         if (err)
3861                 goto err_node_block;
3862         return 0;
3863
3864 err_node_block:
3865         percpu_counter_destroy(&sbi->rf_node_block_count);
3866 err_valid_block:
3867         percpu_counter_destroy(&sbi->alloc_valid_block_count);
3868         return err;
3869 }
3870
3871 #ifdef CONFIG_BLK_DEV_ZONED
3872
3873 struct f2fs_report_zones_args {
3874         struct f2fs_sb_info *sbi;
3875         struct f2fs_dev_info *dev;
3876 };
3877
3878 static int f2fs_report_zone_cb(struct blk_zone *zone, unsigned int idx,
3879                               void *data)
3880 {
3881         struct f2fs_report_zones_args *rz_args = data;
3882         block_t unusable_blocks = (zone->len - zone->capacity) >>
3883                                         F2FS_LOG_SECTORS_PER_BLOCK;
3884
3885         if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)
3886                 return 0;
3887
3888         set_bit(idx, rz_args->dev->blkz_seq);
3889         if (!rz_args->sbi->unusable_blocks_per_sec) {
3890                 rz_args->sbi->unusable_blocks_per_sec = unusable_blocks;
3891                 return 0;
3892         }
3893         if (rz_args->sbi->unusable_blocks_per_sec != unusable_blocks) {
3894                 f2fs_err(rz_args->sbi, "F2FS supports single zone capacity\n");
3895                 return -EINVAL;
3896         }
3897         return 0;
3898 }
3899
3900 static int init_blkz_info(struct f2fs_sb_info *sbi, int devi)
3901 {
3902         struct block_device *bdev = FDEV(devi).bdev;
3903         sector_t nr_sectors = bdev_nr_sectors(bdev);
3904         struct f2fs_report_zones_args rep_zone_arg;
3905         u64 zone_sectors;
3906         unsigned int max_open_zones;
3907         int ret;
3908
3909         if (!f2fs_sb_has_blkzoned(sbi))
3910                 return 0;
3911
3912         if (bdev_is_zoned(FDEV(devi).bdev)) {
3913                 max_open_zones = bdev_max_open_zones(bdev);
3914                 if (max_open_zones && (max_open_zones < sbi->max_open_zones))
3915                         sbi->max_open_zones = max_open_zones;
3916                 if (sbi->max_open_zones < F2FS_OPTION(sbi).active_logs) {
3917                         f2fs_err(sbi,
3918                                 "zoned: max open zones %u is too small, need at least %u open zones",
3919                                 sbi->max_open_zones, F2FS_OPTION(sbi).active_logs);
3920                         return -EINVAL;
3921                 }
3922         }
3923
3924         zone_sectors = bdev_zone_sectors(bdev);
3925         if (sbi->blocks_per_blkz && sbi->blocks_per_blkz !=
3926                                 SECTOR_TO_BLOCK(zone_sectors))
3927                 return -EINVAL;
3928         sbi->blocks_per_blkz = SECTOR_TO_BLOCK(zone_sectors);
3929         FDEV(devi).nr_blkz = div_u64(SECTOR_TO_BLOCK(nr_sectors),
3930                                         sbi->blocks_per_blkz);
3931         if (nr_sectors & (zone_sectors - 1))
3932                 FDEV(devi).nr_blkz++;
3933
3934         FDEV(devi).blkz_seq = f2fs_kvzalloc(sbi,
3935                                         BITS_TO_LONGS(FDEV(devi).nr_blkz)
3936                                         * sizeof(unsigned long),
3937                                         GFP_KERNEL);
3938         if (!FDEV(devi).blkz_seq)
3939                 return -ENOMEM;
3940
3941         rep_zone_arg.sbi = sbi;
3942         rep_zone_arg.dev = &FDEV(devi);
3943
3944         ret = blkdev_report_zones(bdev, 0, BLK_ALL_ZONES, f2fs_report_zone_cb,
3945                                   &rep_zone_arg);
3946         if (ret < 0)
3947                 return ret;
3948         return 0;
3949 }
3950 #endif
3951
3952 /*
3953  * Read f2fs raw super block.
3954  * Because we have two copies of super block, so read both of them
3955  * to get the first valid one. If any one of them is broken, we pass
3956  * them recovery flag back to the caller.
3957  */
3958 static int read_raw_super_block(struct f2fs_sb_info *sbi,
3959                         struct f2fs_super_block **raw_super,
3960                         int *valid_super_block, int *recovery)
3961 {
3962         struct super_block *sb = sbi->sb;
3963         int block;
3964         struct folio *folio;
3965         struct f2fs_super_block *super;
3966         int err = 0;
3967
3968         super = kzalloc(sizeof(struct f2fs_super_block), GFP_KERNEL);
3969         if (!super)
3970                 return -ENOMEM;
3971
3972         for (block = 0; block < 2; block++) {
3973                 folio = read_mapping_folio(sb->s_bdev->bd_mapping, block, NULL);
3974                 if (IS_ERR(folio)) {
3975                         f2fs_err(sbi, "Unable to read %dth superblock",
3976                                  block + 1);
3977                         err = PTR_ERR(folio);
3978                         *recovery = 1;
3979                         continue;
3980                 }
3981
3982                 /* sanity checking of raw super */
3983                 err = sanity_check_raw_super(sbi, folio, block);
3984                 if (err) {
3985                         f2fs_err(sbi, "Can't find valid F2FS filesystem in %dth superblock",
3986                                  block + 1);
3987                         folio_put(folio);
3988                         *recovery = 1;
3989                         continue;
3990                 }
3991
3992                 if (!*raw_super) {
3993                         memcpy(super, F2FS_SUPER_BLOCK(folio, block),
3994                                                         sizeof(*super));
3995                         *valid_super_block = block;
3996                         *raw_super = super;
3997                 }
3998                 folio_put(folio);
3999         }
4000
4001         /* No valid superblock */
4002         if (!*raw_super)
4003                 kfree(super);
4004         else
4005                 err = 0;
4006
4007         return err;
4008 }
4009
4010 int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover)
4011 {
4012         struct folio *folio;
4013         pgoff_t index;
4014         __u32 crc = 0;
4015         int err;
4016
4017         if ((recover && f2fs_readonly(sbi->sb)) ||
4018                                 f2fs_hw_is_readonly(sbi)) {
4019                 set_sbi_flag(sbi, SBI_NEED_SB_WRITE);
4020                 return -EROFS;
4021         }
4022
4023         /* we should update superblock crc here */
4024         if (!recover && f2fs_sb_has_sb_chksum(sbi)) {
4025                 crc = f2fs_crc32(sbi, F2FS_RAW_SUPER(sbi),
4026                                 offsetof(struct f2fs_super_block, crc));
4027                 F2FS_RAW_SUPER(sbi)->crc = cpu_to_le32(crc);
4028         }
4029
4030         /* write back-up superblock first */
4031         index = sbi->valid_super_block ? 0 : 1;
4032         folio = read_mapping_folio(sbi->sb->s_bdev->bd_mapping, index, NULL);
4033         if (IS_ERR(folio))
4034                 return PTR_ERR(folio);
4035         err = __f2fs_commit_super(sbi, folio, index, true);
4036         folio_put(folio);
4037
4038         /* if we are in recovery path, skip writing valid superblock */
4039         if (recover || err)
4040                 return err;
4041
4042         /* write current valid superblock */
4043         index = sbi->valid_super_block;
4044         folio = read_mapping_folio(sbi->sb->s_bdev->bd_mapping, index, NULL);
4045         if (IS_ERR(folio))
4046                 return PTR_ERR(folio);
4047         err = __f2fs_commit_super(sbi, folio, index, true);
4048         folio_put(folio);
4049         return err;
4050 }
4051
4052 static void save_stop_reason(struct f2fs_sb_info *sbi, unsigned char reason)
4053 {
4054         unsigned long flags;
4055
4056         spin_lock_irqsave(&sbi->error_lock, flags);
4057         if (sbi->stop_reason[reason] < GENMASK(BITS_PER_BYTE - 1, 0))
4058                 sbi->stop_reason[reason]++;
4059         spin_unlock_irqrestore(&sbi->error_lock, flags);
4060 }
4061
4062 static void f2fs_record_stop_reason(struct f2fs_sb_info *sbi)
4063 {
4064         struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
4065         unsigned long flags;
4066         int err;
4067
4068         f2fs_down_write(&sbi->sb_lock);
4069
4070         spin_lock_irqsave(&sbi->error_lock, flags);
4071         if (sbi->error_dirty) {
4072                 memcpy(F2FS_RAW_SUPER(sbi)->s_errors, sbi->errors,
4073                                                         MAX_F2FS_ERRORS);
4074                 sbi->error_dirty = false;
4075         }
4076         memcpy(raw_super->s_stop_reason, sbi->stop_reason, MAX_STOP_REASON);
4077         spin_unlock_irqrestore(&sbi->error_lock, flags);
4078
4079         err = f2fs_commit_super(sbi, false);
4080
4081         f2fs_up_write(&sbi->sb_lock);
4082         if (err)
4083                 f2fs_err_ratelimited(sbi,
4084                         "f2fs_commit_super fails to record stop_reason, err:%d",
4085                         err);
4086 }
4087
4088 void f2fs_save_errors(struct f2fs_sb_info *sbi, unsigned char flag)
4089 {
4090         unsigned long flags;
4091
4092         spin_lock_irqsave(&sbi->error_lock, flags);
4093         if (!test_bit(flag, (unsigned long *)sbi->errors)) {
4094                 set_bit(flag, (unsigned long *)sbi->errors);
4095                 sbi->error_dirty = true;
4096         }
4097         spin_unlock_irqrestore(&sbi->error_lock, flags);
4098 }
4099
4100 static bool f2fs_update_errors(struct f2fs_sb_info *sbi)
4101 {
4102         unsigned long flags;
4103         bool need_update = false;
4104
4105         spin_lock_irqsave(&sbi->error_lock, flags);
4106         if (sbi->error_dirty) {
4107                 memcpy(F2FS_RAW_SUPER(sbi)->s_errors, sbi->errors,
4108                                                         MAX_F2FS_ERRORS);
4109                 sbi->error_dirty = false;
4110                 need_update = true;
4111         }
4112         spin_unlock_irqrestore(&sbi->error_lock, flags);
4113
4114         return need_update;
4115 }
4116
4117 static void f2fs_record_errors(struct f2fs_sb_info *sbi, unsigned char error)
4118 {
4119         int err;
4120
4121         f2fs_down_write(&sbi->sb_lock);
4122
4123         if (!f2fs_update_errors(sbi))
4124                 goto out_unlock;
4125
4126         err = f2fs_commit_super(sbi, false);
4127         if (err)
4128                 f2fs_err_ratelimited(sbi,
4129                         "f2fs_commit_super fails to record errors:%u, err:%d",
4130                         error, err);
4131 out_unlock:
4132         f2fs_up_write(&sbi->sb_lock);
4133 }
4134
4135 void f2fs_handle_error(struct f2fs_sb_info *sbi, unsigned char error)
4136 {
4137         f2fs_save_errors(sbi, error);
4138         f2fs_record_errors(sbi, error);
4139 }
4140
4141 void f2fs_handle_error_async(struct f2fs_sb_info *sbi, unsigned char error)
4142 {
4143         f2fs_save_errors(sbi, error);
4144
4145         if (!sbi->error_dirty)
4146                 return;
4147         if (!test_bit(error, (unsigned long *)sbi->errors))
4148                 return;
4149         schedule_work(&sbi->s_error_work);
4150 }
4151
4152 static bool system_going_down(void)
4153 {
4154         return system_state == SYSTEM_HALT || system_state == SYSTEM_POWER_OFF
4155                 || system_state == SYSTEM_RESTART;
4156 }
4157
4158 void f2fs_handle_critical_error(struct f2fs_sb_info *sbi, unsigned char reason,
4159                                                         bool irq_context)
4160 {
4161         struct super_block *sb = sbi->sb;
4162         bool shutdown = reason == STOP_CP_REASON_SHUTDOWN;
4163         bool continue_fs = !shutdown &&
4164                         F2FS_OPTION(sbi).errors == MOUNT_ERRORS_CONTINUE;
4165
4166         set_ckpt_flags(sbi, CP_ERROR_FLAG);
4167
4168         if (!f2fs_hw_is_readonly(sbi)) {
4169                 save_stop_reason(sbi, reason);
4170
4171                 if (irq_context && !shutdown)
4172                         schedule_work(&sbi->s_error_work);
4173                 else
4174                         f2fs_record_stop_reason(sbi);
4175         }
4176
4177         /*
4178          * We force ERRORS_RO behavior when system is rebooting. Otherwise we
4179          * could panic during 'reboot -f' as the underlying device got already
4180          * disabled.
4181          */
4182         if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_PANIC &&
4183                                 !shutdown && !system_going_down() &&
4184                                 !is_sbi_flag_set(sbi, SBI_IS_SHUTDOWN))
4185                 panic("F2FS-fs (device %s): panic forced after error\n",
4186                                                         sb->s_id);
4187
4188         if (shutdown)
4189                 set_sbi_flag(sbi, SBI_IS_SHUTDOWN);
4190
4191         /*
4192          * Continue filesystem operators if errors=continue. Should not set
4193          * RO by shutdown, since RO bypasses thaw_super which can hang the
4194          * system.
4195          */
4196         if (continue_fs || f2fs_readonly(sb) || shutdown) {
4197                 f2fs_warn(sbi, "Stopped filesystem due to reason: %d", reason);
4198                 return;
4199         }
4200
4201         f2fs_warn(sbi, "Remounting filesystem read-only");
4202
4203         /*
4204          * We have already set CP_ERROR_FLAG flag to stop all updates
4205          * to filesystem, so it doesn't need to set SB_RDONLY flag here
4206          * because the flag should be set covered w/ sb->s_umount semaphore
4207          * via remount procedure, otherwise, it will confuse code like
4208          * freeze_super() which will lead to deadlocks and other problems.
4209          */
4210 }
4211
4212 static void f2fs_record_error_work(struct work_struct *work)
4213 {
4214         struct f2fs_sb_info *sbi = container_of(work,
4215                                         struct f2fs_sb_info, s_error_work);
4216
4217         f2fs_record_stop_reason(sbi);
4218 }
4219
4220 static int f2fs_scan_devices(struct f2fs_sb_info *sbi)
4221 {
4222         struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
4223         unsigned int max_devices = MAX_DEVICES;
4224         unsigned int logical_blksize;
4225         blk_mode_t mode = sb_open_mode(sbi->sb->s_flags);
4226         int i;
4227
4228         /* Initialize single device information */
4229         if (!RDEV(0).path[0]) {
4230                 if (!bdev_is_zoned(sbi->sb->s_bdev))
4231                         return 0;
4232                 max_devices = 1;
4233         }
4234
4235         /*
4236          * Initialize multiple devices information, or single
4237          * zoned block device information.
4238          */
4239         sbi->devs = f2fs_kzalloc(sbi,
4240                                  array_size(max_devices,
4241                                             sizeof(struct f2fs_dev_info)),
4242                                  GFP_KERNEL);
4243         if (!sbi->devs)
4244                 return -ENOMEM;
4245
4246         logical_blksize = bdev_logical_block_size(sbi->sb->s_bdev);
4247         sbi->aligned_blksize = true;
4248 #ifdef CONFIG_BLK_DEV_ZONED
4249         sbi->max_open_zones = UINT_MAX;
4250         sbi->blkzone_alloc_policy = BLKZONE_ALLOC_PRIOR_SEQ;
4251 #endif
4252
4253         for (i = 0; i < max_devices; i++) {
4254                 if (i == 0)
4255                         FDEV(0).bdev_file = sbi->sb->s_bdev_file;
4256                 else if (!RDEV(i).path[0])
4257                         break;
4258
4259                 if (max_devices > 1) {
4260                         /* Multi-device mount */
4261                         memcpy(FDEV(i).path, RDEV(i).path, MAX_PATH_LEN);
4262                         FDEV(i).total_segments =
4263                                 le32_to_cpu(RDEV(i).total_segments);
4264                         if (i == 0) {
4265                                 FDEV(i).start_blk = 0;
4266                                 FDEV(i).end_blk = FDEV(i).start_blk +
4267                                         SEGS_TO_BLKS(sbi,
4268                                         FDEV(i).total_segments) - 1 +
4269                                         le32_to_cpu(raw_super->segment0_blkaddr);
4270                         } else {
4271                                 FDEV(i).start_blk = FDEV(i - 1).end_blk + 1;
4272                                 FDEV(i).end_blk = FDEV(i).start_blk +
4273                                                 SEGS_TO_BLKS(sbi,
4274                                                 FDEV(i).total_segments) - 1;
4275                                 FDEV(i).bdev_file = bdev_file_open_by_path(
4276                                         FDEV(i).path, mode, sbi->sb, NULL);
4277                         }
4278                 }
4279                 if (IS_ERR(FDEV(i).bdev_file))
4280                         return PTR_ERR(FDEV(i).bdev_file);
4281
4282                 FDEV(i).bdev = file_bdev(FDEV(i).bdev_file);
4283                 /* to release errored devices */
4284                 sbi->s_ndevs = i + 1;
4285
4286                 if (logical_blksize != bdev_logical_block_size(FDEV(i).bdev))
4287                         sbi->aligned_blksize = false;
4288
4289 #ifdef CONFIG_BLK_DEV_ZONED
4290                 if (bdev_is_zoned(FDEV(i).bdev)) {
4291                         if (!f2fs_sb_has_blkzoned(sbi)) {
4292                                 f2fs_err(sbi, "Zoned block device feature not enabled");
4293                                 return -EINVAL;
4294                         }
4295                         if (init_blkz_info(sbi, i)) {
4296                                 f2fs_err(sbi, "Failed to initialize F2FS blkzone information");
4297                                 return -EINVAL;
4298                         }
4299                         if (max_devices == 1)
4300                                 break;
4301                         f2fs_info(sbi, "Mount Device [%2d]: %20s, %8u, %8x - %8x (zone: Host-managed)",
4302                                   i, FDEV(i).path,
4303                                   FDEV(i).total_segments,
4304                                   FDEV(i).start_blk, FDEV(i).end_blk);
4305                         continue;
4306                 }
4307 #endif
4308                 f2fs_info(sbi, "Mount Device [%2d]: %20s, %8u, %8x - %8x",
4309                           i, FDEV(i).path,
4310                           FDEV(i).total_segments,
4311                           FDEV(i).start_blk, FDEV(i).end_blk);
4312         }
4313         return 0;
4314 }
4315
4316 static int f2fs_setup_casefold(struct f2fs_sb_info *sbi)
4317 {
4318 #if IS_ENABLED(CONFIG_UNICODE)
4319         if (f2fs_sb_has_casefold(sbi) && !sbi->sb->s_encoding) {
4320                 const struct f2fs_sb_encodings *encoding_info;
4321                 struct unicode_map *encoding;
4322                 __u16 encoding_flags;
4323
4324                 encoding_info = f2fs_sb_read_encoding(sbi->raw_super);
4325                 if (!encoding_info) {
4326                         f2fs_err(sbi,
4327                                  "Encoding requested by superblock is unknown");
4328                         return -EINVAL;
4329                 }
4330
4331                 encoding_flags = le16_to_cpu(sbi->raw_super->s_encoding_flags);
4332                 encoding = utf8_load(encoding_info->version);
4333                 if (IS_ERR(encoding)) {
4334                         f2fs_err(sbi,
4335                                  "can't mount with superblock charset: %s-%u.%u.%u "
4336                                  "not supported by the kernel. flags: 0x%x.",
4337                                  encoding_info->name,
4338                                  unicode_major(encoding_info->version),
4339                                  unicode_minor(encoding_info->version),
4340                                  unicode_rev(encoding_info->version),
4341                                  encoding_flags);
4342                         return PTR_ERR(encoding);
4343                 }
4344                 f2fs_info(sbi, "Using encoding defined by superblock: "
4345                          "%s-%u.%u.%u with flags 0x%hx", encoding_info->name,
4346                          unicode_major(encoding_info->version),
4347                          unicode_minor(encoding_info->version),
4348                          unicode_rev(encoding_info->version),
4349                          encoding_flags);
4350
4351                 sbi->sb->s_encoding = encoding;
4352                 sbi->sb->s_encoding_flags = encoding_flags;
4353         }
4354 #else
4355         if (f2fs_sb_has_casefold(sbi)) {
4356                 f2fs_err(sbi, "Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");
4357                 return -EINVAL;
4358         }
4359 #endif
4360         return 0;
4361 }
4362
4363 static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
4364 {
4365         /* adjust parameters according to the volume size */
4366         if (MAIN_SEGS(sbi) <= SMALL_VOLUME_SEGMENTS) {
4367                 if (f2fs_block_unit_discard(sbi))
4368                         SM_I(sbi)->dcc_info->discard_granularity =
4369                                                 MIN_DISCARD_GRANULARITY;
4370                 if (!f2fs_lfs_mode(sbi))
4371                         SM_I(sbi)->ipu_policy = BIT(F2FS_IPU_FORCE) |
4372                                                 BIT(F2FS_IPU_HONOR_OPU_WRITE);
4373         }
4374
4375         sbi->readdir_ra = true;
4376 }
4377
4378 static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
4379 {
4380         struct f2fs_sb_info *sbi;
4381         struct f2fs_super_block *raw_super;
4382         struct inode *root;
4383         int err;
4384         bool skip_recovery = false, need_fsck = false;
4385         char *options = NULL;
4386         int recovery, i, valid_super_block;
4387         struct curseg_info *seg_i;
4388         int retry_cnt = 1;
4389 #ifdef CONFIG_QUOTA
4390         bool quota_enabled = false;
4391 #endif
4392
4393 try_onemore:
4394         err = -EINVAL;
4395         raw_super = NULL;
4396         valid_super_block = -1;
4397         recovery = 0;
4398
4399         /* allocate memory for f2fs-specific super block info */
4400         sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
4401         if (!sbi)
4402                 return -ENOMEM;
4403
4404         sbi->sb = sb;
4405
4406         /* initialize locks within allocated memory */
4407         init_f2fs_rwsem(&sbi->gc_lock);
4408         mutex_init(&sbi->writepages);
4409         init_f2fs_rwsem(&sbi->cp_global_sem);
4410         init_f2fs_rwsem(&sbi->node_write);
4411         init_f2fs_rwsem(&sbi->node_change);
4412         spin_lock_init(&sbi->stat_lock);
4413         init_f2fs_rwsem(&sbi->cp_rwsem);
4414         init_f2fs_rwsem(&sbi->quota_sem);
4415         init_waitqueue_head(&sbi->cp_wait);
4416         spin_lock_init(&sbi->error_lock);
4417
4418         for (i = 0; i < NR_INODE_TYPE; i++) {
4419                 INIT_LIST_HEAD(&sbi->inode_list[i]);
4420                 spin_lock_init(&sbi->inode_lock[i]);
4421         }
4422         mutex_init(&sbi->flush_lock);
4423
4424         /* Load the checksum driver */
4425         sbi->s_chksum_driver = crypto_alloc_shash("crc32", 0, 0);
4426         if (IS_ERR(sbi->s_chksum_driver)) {
4427                 f2fs_err(sbi, "Cannot load crc32 driver.");
4428                 err = PTR_ERR(sbi->s_chksum_driver);
4429                 sbi->s_chksum_driver = NULL;
4430                 goto free_sbi;
4431         }
4432
4433         /* set a block size */
4434         if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) {
4435                 f2fs_err(sbi, "unable to set blocksize");
4436                 goto free_sbi;
4437         }
4438
4439         err = read_raw_super_block(sbi, &raw_super, &valid_super_block,
4440                                                                 &recovery);
4441         if (err)
4442                 goto free_sbi;
4443
4444         sb->s_fs_info = sbi;
4445         sbi->raw_super = raw_super;
4446
4447         INIT_WORK(&sbi->s_error_work, f2fs_record_error_work);
4448         memcpy(sbi->errors, raw_super->s_errors, MAX_F2FS_ERRORS);
4449         memcpy(sbi->stop_reason, raw_super->s_stop_reason, MAX_STOP_REASON);
4450
4451         /* precompute checksum seed for metadata */
4452         if (f2fs_sb_has_inode_chksum(sbi))
4453                 sbi->s_chksum_seed = f2fs_chksum(sbi, ~0, raw_super->uuid,
4454                                                 sizeof(raw_super->uuid));
4455
4456         default_options(sbi, false);
4457         /* parse mount options */
4458         options = kstrdup((const char *)data, GFP_KERNEL);
4459         if (data && !options) {
4460                 err = -ENOMEM;
4461                 goto free_sb_buf;
4462         }
4463
4464         err = parse_options(sb, options, false);
4465         if (err)
4466                 goto free_options;
4467
4468         sb->s_maxbytes = max_file_blocks(NULL) <<
4469                                 le32_to_cpu(raw_super->log_blocksize);
4470         sb->s_max_links = F2FS_LINK_MAX;
4471
4472         err = f2fs_setup_casefold(sbi);
4473         if (err)
4474                 goto free_options;
4475
4476 #ifdef CONFIG_QUOTA
4477         sb->dq_op = &f2fs_quota_operations;
4478         sb->s_qcop = &f2fs_quotactl_ops;
4479         sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;
4480
4481         if (f2fs_sb_has_quota_ino(sbi)) {
4482                 for (i = 0; i < MAXQUOTAS; i++) {
4483                         if (f2fs_qf_ino(sbi->sb, i))
4484                                 sbi->nquota_files++;
4485                 }
4486         }
4487 #endif
4488
4489         sb->s_op = &f2fs_sops;
4490 #ifdef CONFIG_FS_ENCRYPTION
4491         sb->s_cop = &f2fs_cryptops;
4492 #endif
4493 #ifdef CONFIG_FS_VERITY
4494         sb->s_vop = &f2fs_verityops;
4495 #endif
4496         sb->s_xattr = f2fs_xattr_handlers;
4497         sb->s_export_op = &f2fs_export_ops;
4498         sb->s_magic = F2FS_SUPER_MAGIC;
4499         sb->s_time_gran = 1;
4500         sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
4501                 (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
4502         super_set_uuid(sb, (void *) raw_super->uuid, sizeof(raw_super->uuid));
4503         super_set_sysfs_name_bdev(sb);
4504         sb->s_iflags |= SB_I_CGROUPWB;
4505
4506         /* init f2fs-specific super block info */
4507         sbi->valid_super_block = valid_super_block;
4508
4509         /* disallow all the data/node/meta page writes */
4510         set_sbi_flag(sbi, SBI_POR_DOING);
4511
4512         err = f2fs_init_write_merge_io(sbi);
4513         if (err)
4514                 goto free_bio_info;
4515
4516         init_sb_info(sbi);
4517
4518         err = f2fs_init_iostat(sbi);
4519         if (err)
4520                 goto free_bio_info;
4521
4522         err = init_percpu_info(sbi);
4523         if (err)
4524                 goto free_iostat;
4525
4526         /* init per sbi slab cache */
4527         err = f2fs_init_xattr_caches(sbi);
4528         if (err)
4529                 goto free_percpu;
4530         err = f2fs_init_page_array_cache(sbi);
4531         if (err)
4532                 goto free_xattr_cache;
4533
4534         /* get an inode for meta space */
4535         sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi));
4536         if (IS_ERR(sbi->meta_inode)) {
4537                 f2fs_err(sbi, "Failed to read F2FS meta data inode");
4538                 err = PTR_ERR(sbi->meta_inode);
4539                 goto free_page_array_cache;
4540         }
4541
4542         err = f2fs_get_valid_checkpoint(sbi);
4543         if (err) {
4544                 f2fs_err(sbi, "Failed to get valid F2FS checkpoint");
4545                 goto free_meta_inode;
4546         }
4547
4548         if (__is_set_ckpt_flags(F2FS_CKPT(sbi), CP_QUOTA_NEED_FSCK_FLAG))
4549                 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
4550         if (__is_set_ckpt_flags(F2FS_CKPT(sbi), CP_DISABLED_QUICK_FLAG)) {
4551                 set_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);
4552                 sbi->interval_time[DISABLE_TIME] = DEF_DISABLE_QUICK_INTERVAL;
4553         }
4554
4555         if (__is_set_ckpt_flags(F2FS_CKPT(sbi), CP_FSCK_FLAG))
4556                 set_sbi_flag(sbi, SBI_NEED_FSCK);
4557
4558         /* Initialize device list */
4559         err = f2fs_scan_devices(sbi);
4560         if (err) {
4561                 f2fs_err(sbi, "Failed to find devices");
4562                 goto free_devices;
4563         }
4564
4565         err = f2fs_init_post_read_wq(sbi);
4566         if (err) {
4567                 f2fs_err(sbi, "Failed to initialize post read workqueue");
4568                 goto free_devices;
4569         }
4570
4571         sbi->total_valid_node_count =
4572                                 le32_to_cpu(sbi->ckpt->valid_node_count);
4573         percpu_counter_set(&sbi->total_valid_inode_count,
4574                                 le32_to_cpu(sbi->ckpt->valid_inode_count));
4575         sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count);
4576         sbi->total_valid_block_count =
4577                                 le64_to_cpu(sbi->ckpt->valid_block_count);
4578         sbi->last_valid_block_count = sbi->total_valid_block_count;
4579         sbi->reserved_blocks = 0;
4580         sbi->current_reserved_blocks = 0;
4581         limit_reserve_root(sbi);
4582         adjust_unusable_cap_perc(sbi);
4583
4584         f2fs_init_extent_cache_info(sbi);
4585
4586         f2fs_init_ino_entry_info(sbi);
4587
4588         f2fs_init_fsync_node_info(sbi);
4589
4590         /* setup checkpoint request control and start checkpoint issue thread */
4591         f2fs_init_ckpt_req_control(sbi);
4592         if (!f2fs_readonly(sb) && !test_opt(sbi, DISABLE_CHECKPOINT) &&
4593                         test_opt(sbi, MERGE_CHECKPOINT)) {
4594                 err = f2fs_start_ckpt_thread(sbi);
4595                 if (err) {
4596                         f2fs_err(sbi,
4597                             "Failed to start F2FS issue_checkpoint_thread (%d)",
4598                             err);
4599                         goto stop_ckpt_thread;
4600                 }
4601         }
4602
4603         /* setup f2fs internal modules */
4604         err = f2fs_build_segment_manager(sbi);
4605         if (err) {
4606                 f2fs_err(sbi, "Failed to initialize F2FS segment manager (%d)",
4607                          err);
4608                 goto free_sm;
4609         }
4610         err = f2fs_build_node_manager(sbi);
4611         if (err) {
4612                 f2fs_err(sbi, "Failed to initialize F2FS node manager (%d)",
4613                          err);
4614                 goto free_nm;
4615         }
4616
4617         /* For write statistics */
4618         sbi->sectors_written_start = f2fs_get_sectors_written(sbi);
4619
4620         /* Read accumulated write IO statistics if exists */
4621         seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);
4622         if (__exist_node_summaries(sbi))
4623                 sbi->kbytes_written =
4624                         le64_to_cpu(seg_i->journal->info.kbytes_written);
4625
4626         f2fs_build_gc_manager(sbi);
4627
4628         err = f2fs_build_stats(sbi);
4629         if (err)
4630                 goto free_nm;
4631
4632         /* get an inode for node space */
4633         sbi->node_inode = f2fs_iget(sb, F2FS_NODE_INO(sbi));
4634         if (IS_ERR(sbi->node_inode)) {
4635                 f2fs_err(sbi, "Failed to read node inode");
4636                 err = PTR_ERR(sbi->node_inode);
4637                 goto free_stats;
4638         }
4639
4640         /* read root inode and dentry */
4641         root = f2fs_iget(sb, F2FS_ROOT_INO(sbi));
4642         if (IS_ERR(root)) {
4643                 f2fs_err(sbi, "Failed to read root inode");
4644                 err = PTR_ERR(root);
4645                 goto free_node_inode;
4646         }
4647         if (!S_ISDIR(root->i_mode) || !root->i_blocks ||
4648                         !root->i_size || !root->i_nlink) {
4649                 iput(root);
4650                 err = -EINVAL;
4651                 goto free_node_inode;
4652         }
4653
4654         generic_set_sb_d_ops(sb);
4655         sb->s_root = d_make_root(root); /* allocate root dentry */
4656         if (!sb->s_root) {
4657                 err = -ENOMEM;
4658                 goto free_node_inode;
4659         }
4660
4661         err = f2fs_init_compress_inode(sbi);
4662         if (err)
4663                 goto free_root_inode;
4664
4665         err = f2fs_register_sysfs(sbi);
4666         if (err)
4667                 goto free_compress_inode;
4668
4669 #ifdef CONFIG_QUOTA
4670         /* Enable quota usage during mount */
4671         if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sb)) {
4672                 err = f2fs_enable_quotas(sb);
4673                 if (err)
4674                         f2fs_err(sbi, "Cannot turn on quotas: error %d", err);
4675         }
4676
4677         quota_enabled = f2fs_recover_quota_begin(sbi);
4678 #endif
4679         /* if there are any orphan inodes, free them */
4680         err = f2fs_recover_orphan_inodes(sbi);
4681         if (err)
4682                 goto free_meta;
4683
4684         if (unlikely(is_set_ckpt_flags(sbi, CP_DISABLED_FLAG)))
4685                 goto reset_checkpoint;
4686
4687         /* recover fsynced data */
4688         if (!test_opt(sbi, DISABLE_ROLL_FORWARD) &&
4689                         !test_opt(sbi, NORECOVERY)) {
4690                 /*
4691                  * mount should be failed, when device has readonly mode, and
4692                  * previous checkpoint was not done by clean system shutdown.
4693                  */
4694                 if (f2fs_hw_is_readonly(sbi)) {
4695                         if (!is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
4696                                 err = f2fs_recover_fsync_data(sbi, true);
4697                                 if (err > 0) {
4698                                         err = -EROFS;
4699                                         f2fs_err(sbi, "Need to recover fsync data, but "
4700                                                 "write access unavailable, please try "
4701                                                 "mount w/ disable_roll_forward or norecovery");
4702                                 }
4703                                 if (err < 0)
4704                                         goto free_meta;
4705                         }
4706                         f2fs_info(sbi, "write access unavailable, skipping recovery");
4707                         goto reset_checkpoint;
4708                 }
4709
4710                 if (need_fsck)
4711                         set_sbi_flag(sbi, SBI_NEED_FSCK);
4712
4713                 if (skip_recovery)
4714                         goto reset_checkpoint;
4715
4716                 err = f2fs_recover_fsync_data(sbi, false);
4717                 if (err < 0) {
4718                         if (err != -ENOMEM)
4719                                 skip_recovery = true;
4720                         need_fsck = true;
4721                         f2fs_err(sbi, "Cannot recover all fsync data errno=%d",
4722                                  err);
4723                         goto free_meta;
4724                 }
4725         } else {
4726                 err = f2fs_recover_fsync_data(sbi, true);
4727
4728                 if (!f2fs_readonly(sb) && err > 0) {
4729                         err = -EINVAL;
4730                         f2fs_err(sbi, "Need to recover fsync data");
4731                         goto free_meta;
4732                 }
4733         }
4734
4735 #ifdef CONFIG_QUOTA
4736         f2fs_recover_quota_end(sbi, quota_enabled);
4737 #endif
4738 reset_checkpoint:
4739         /*
4740          * If the f2fs is not readonly and fsync data recovery succeeds,
4741          * check zoned block devices' write pointer consistency.
4742          */
4743         if (f2fs_sb_has_blkzoned(sbi) && !f2fs_readonly(sb)) {
4744                 int err2;
4745
4746                 f2fs_notice(sbi, "Checking entire write pointers");
4747                 err2 = f2fs_check_write_pointer(sbi);
4748                 if (err2)
4749                         err = err2;
4750         }
4751         if (err)
4752                 goto free_meta;
4753
4754         err = f2fs_init_inmem_curseg(sbi);
4755         if (err)
4756                 goto sync_free_meta;
4757
4758         /* f2fs_recover_fsync_data() cleared this already */
4759         clear_sbi_flag(sbi, SBI_POR_DOING);
4760
4761         if (test_opt(sbi, DISABLE_CHECKPOINT)) {
4762                 err = f2fs_disable_checkpoint(sbi);
4763                 if (err)
4764                         goto sync_free_meta;
4765         } else if (is_set_ckpt_flags(sbi, CP_DISABLED_FLAG)) {
4766                 f2fs_enable_checkpoint(sbi);
4767         }
4768
4769         /*
4770          * If filesystem is not mounted as read-only then
4771          * do start the gc_thread.
4772          */
4773         if ((F2FS_OPTION(sbi).bggc_mode != BGGC_MODE_OFF ||
4774                 test_opt(sbi, GC_MERGE)) && !f2fs_readonly(sb)) {
4775                 /* After POR, we can run background GC thread.*/
4776                 err = f2fs_start_gc_thread(sbi);
4777                 if (err)
4778                         goto sync_free_meta;
4779         }
4780         kvfree(options);
4781
4782         /* recover broken superblock */
4783         if (recovery) {
4784                 err = f2fs_commit_super(sbi, true);
4785                 f2fs_info(sbi, "Try to recover %dth superblock, ret: %d",
4786                           sbi->valid_super_block ? 1 : 2, err);
4787         }
4788
4789         f2fs_join_shrinker(sbi);
4790
4791         f2fs_tuning_parameters(sbi);
4792
4793         f2fs_notice(sbi, "Mounted with checkpoint version = %llx",
4794                     cur_cp_version(F2FS_CKPT(sbi)));
4795         f2fs_update_time(sbi, CP_TIME);
4796         f2fs_update_time(sbi, REQ_TIME);
4797         clear_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);
4798         return 0;
4799
4800 sync_free_meta:
4801         /* safe to flush all the data */
4802         sync_filesystem(sbi->sb);
4803         retry_cnt = 0;
4804
4805 free_meta:
4806 #ifdef CONFIG_QUOTA
4807         f2fs_truncate_quota_inode_pages(sb);
4808         if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sb))
4809                 f2fs_quota_off_umount(sbi->sb);
4810 #endif
4811         /*
4812          * Some dirty meta pages can be produced by f2fs_recover_orphan_inodes()
4813          * failed by EIO. Then, iput(node_inode) can trigger balance_fs_bg()
4814          * followed by f2fs_write_checkpoint() through f2fs_write_node_pages(), which
4815          * falls into an infinite loop in f2fs_sync_meta_pages().
4816          */
4817         truncate_inode_pages_final(META_MAPPING(sbi));
4818         /* evict some inodes being cached by GC */
4819         evict_inodes(sb);
4820         f2fs_unregister_sysfs(sbi);
4821 free_compress_inode:
4822         f2fs_destroy_compress_inode(sbi);
4823 free_root_inode:
4824         dput(sb->s_root);
4825         sb->s_root = NULL;
4826 free_node_inode:
4827         f2fs_release_ino_entry(sbi, true);
4828         truncate_inode_pages_final(NODE_MAPPING(sbi));
4829         iput(sbi->node_inode);
4830         sbi->node_inode = NULL;
4831 free_stats:
4832         f2fs_destroy_stats(sbi);
4833 free_nm:
4834         /* stop discard thread before destroying node manager */
4835         f2fs_stop_discard_thread(sbi);
4836         f2fs_destroy_node_manager(sbi);
4837 free_sm:
4838         f2fs_destroy_segment_manager(sbi);
4839 stop_ckpt_thread:
4840         f2fs_stop_ckpt_thread(sbi);
4841         /* flush s_error_work before sbi destroy */
4842         flush_work(&sbi->s_error_work);
4843         f2fs_destroy_post_read_wq(sbi);
4844 free_devices:
4845         destroy_device_list(sbi);
4846         kvfree(sbi->ckpt);
4847 free_meta_inode:
4848         make_bad_inode(sbi->meta_inode);
4849         iput(sbi->meta_inode);
4850         sbi->meta_inode = NULL;
4851 free_page_array_cache:
4852         f2fs_destroy_page_array_cache(sbi);
4853 free_xattr_cache:
4854         f2fs_destroy_xattr_caches(sbi);
4855 free_percpu:
4856         destroy_percpu_info(sbi);
4857 free_iostat:
4858         f2fs_destroy_iostat(sbi);
4859 free_bio_info:
4860         for (i = 0; i < NR_PAGE_TYPE; i++)
4861                 kvfree(sbi->write_io[i]);
4862
4863 #if IS_ENABLED(CONFIG_UNICODE)
4864         utf8_unload(sb->s_encoding);
4865         sb->s_encoding = NULL;
4866 #endif
4867 free_options:
4868 #ifdef CONFIG_QUOTA
4869         for (i = 0; i < MAXQUOTAS; i++)
4870                 kfree(F2FS_OPTION(sbi).s_qf_names[i]);
4871 #endif
4872         fscrypt_free_dummy_policy(&F2FS_OPTION(sbi).dummy_enc_policy);
4873         kvfree(options);
4874 free_sb_buf:
4875         kfree(raw_super);
4876 free_sbi:
4877         if (sbi->s_chksum_driver)
4878                 crypto_free_shash(sbi->s_chksum_driver);
4879         kfree(sbi);
4880         sb->s_fs_info = NULL;
4881
4882         /* give only one another chance */
4883         if (retry_cnt > 0 && skip_recovery) {
4884                 retry_cnt--;
4885                 shrink_dcache_sb(sb);
4886                 goto try_onemore;
4887         }
4888         return err;
4889 }
4890
4891 static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags,
4892                         const char *dev_name, void *data)
4893 {
4894         return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super);
4895 }
4896
4897 static void kill_f2fs_super(struct super_block *sb)
4898 {
4899         struct f2fs_sb_info *sbi = F2FS_SB(sb);
4900
4901         if (sb->s_root) {
4902                 set_sbi_flag(sbi, SBI_IS_CLOSE);
4903                 f2fs_stop_gc_thread(sbi);
4904                 f2fs_stop_discard_thread(sbi);
4905
4906 #ifdef CONFIG_F2FS_FS_COMPRESSION
4907                 /*
4908                  * latter evict_inode() can bypass checking and invalidating
4909                  * compress inode cache.
4910                  */
4911                 if (test_opt(sbi, COMPRESS_CACHE))
4912                         truncate_inode_pages_final(COMPRESS_MAPPING(sbi));
4913 #endif
4914
4915                 if (is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||
4916                                 !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
4917                         struct cp_control cpc = {
4918                                 .reason = CP_UMOUNT,
4919                         };
4920                         stat_inc_cp_call_count(sbi, TOTAL_CALL);
4921                         f2fs_write_checkpoint(sbi, &cpc);
4922                 }
4923
4924                 if (is_sbi_flag_set(sbi, SBI_IS_RECOVERED) && f2fs_readonly(sb))
4925                         sb->s_flags &= ~SB_RDONLY;
4926         }
4927         kill_block_super(sb);
4928         /* Release block devices last, after fscrypt_destroy_keyring(). */
4929         if (sbi) {
4930                 destroy_device_list(sbi);
4931                 kfree(sbi);
4932                 sb->s_fs_info = NULL;
4933         }
4934 }
4935
4936 static struct file_system_type f2fs_fs_type = {
4937         .owner          = THIS_MODULE,
4938         .name           = "f2fs",
4939         .mount          = f2fs_mount,
4940         .kill_sb        = kill_f2fs_super,
4941         .fs_flags       = FS_REQUIRES_DEV | FS_ALLOW_IDMAP,
4942 };
4943 MODULE_ALIAS_FS("f2fs");
4944
4945 static int __init init_inodecache(void)
4946 {
4947         f2fs_inode_cachep = kmem_cache_create("f2fs_inode_cache",
4948                         sizeof(struct f2fs_inode_info), 0,
4949                         SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT, NULL);
4950         return f2fs_inode_cachep ? 0 : -ENOMEM;
4951 }
4952
4953 static void destroy_inodecache(void)
4954 {
4955         /*
4956          * Make sure all delayed rcu free inodes are flushed before we
4957          * destroy cache.
4958          */
4959         rcu_barrier();
4960         kmem_cache_destroy(f2fs_inode_cachep);
4961 }
4962
4963 static int __init init_f2fs_fs(void)
4964 {
4965         int err;
4966
4967         err = init_inodecache();
4968         if (err)
4969                 goto fail;
4970         err = f2fs_create_node_manager_caches();
4971         if (err)
4972                 goto free_inodecache;
4973         err = f2fs_create_segment_manager_caches();
4974         if (err)
4975                 goto free_node_manager_caches;
4976         err = f2fs_create_checkpoint_caches();
4977         if (err)
4978                 goto free_segment_manager_caches;
4979         err = f2fs_create_recovery_cache();
4980         if (err)
4981                 goto free_checkpoint_caches;
4982         err = f2fs_create_extent_cache();
4983         if (err)
4984                 goto free_recovery_cache;
4985         err = f2fs_create_garbage_collection_cache();
4986         if (err)
4987                 goto free_extent_cache;
4988         err = f2fs_init_sysfs();
4989         if (err)
4990                 goto free_garbage_collection_cache;
4991         err = f2fs_init_shrinker();
4992         if (err)
4993                 goto free_sysfs;
4994         err = register_filesystem(&f2fs_fs_type);
4995         if (err)
4996                 goto free_shrinker;
4997         f2fs_create_root_stats();
4998         err = f2fs_init_post_read_processing();
4999         if (err)
5000                 goto free_root_stats;
5001         err = f2fs_init_iostat_processing();
5002         if (err)
5003                 goto free_post_read;
5004         err = f2fs_init_bio_entry_cache();
5005         if (err)
5006                 goto free_iostat;
5007         err = f2fs_init_bioset();
5008         if (err)
5009                 goto free_bio_entry_cache;
5010         err = f2fs_init_compress_mempool();
5011         if (err)
5012                 goto free_bioset;
5013         err = f2fs_init_compress_cache();
5014         if (err)
5015                 goto free_compress_mempool;
5016         err = f2fs_create_casefold_cache();
5017         if (err)
5018                 goto free_compress_cache;
5019         return 0;
5020 free_compress_cache:
5021         f2fs_destroy_compress_cache();
5022 free_compress_mempool:
5023         f2fs_destroy_compress_mempool();
5024 free_bioset:
5025         f2fs_destroy_bioset();
5026 free_bio_entry_cache:
5027         f2fs_destroy_bio_entry_cache();
5028 free_iostat:
5029         f2fs_destroy_iostat_processing();
5030 free_post_read:
5031         f2fs_destroy_post_read_processing();
5032 free_root_stats:
5033         f2fs_destroy_root_stats();
5034         unregister_filesystem(&f2fs_fs_type);
5035 free_shrinker:
5036         f2fs_exit_shrinker();
5037 free_sysfs:
5038         f2fs_exit_sysfs();
5039 free_garbage_collection_cache:
5040         f2fs_destroy_garbage_collection_cache();
5041 free_extent_cache:
5042         f2fs_destroy_extent_cache();
5043 free_recovery_cache:
5044         f2fs_destroy_recovery_cache();
5045 free_checkpoint_caches:
5046         f2fs_destroy_checkpoint_caches();
5047 free_segment_manager_caches:
5048         f2fs_destroy_segment_manager_caches();
5049 free_node_manager_caches:
5050         f2fs_destroy_node_manager_caches();
5051 free_inodecache:
5052         destroy_inodecache();
5053 fail:
5054         return err;
5055 }
5056
5057 static void __exit exit_f2fs_fs(void)
5058 {
5059         f2fs_destroy_casefold_cache();
5060         f2fs_destroy_compress_cache();
5061         f2fs_destroy_compress_mempool();
5062         f2fs_destroy_bioset();
5063         f2fs_destroy_bio_entry_cache();
5064         f2fs_destroy_iostat_processing();
5065         f2fs_destroy_post_read_processing();
5066         f2fs_destroy_root_stats();
5067         unregister_filesystem(&f2fs_fs_type);
5068         f2fs_exit_shrinker();
5069         f2fs_exit_sysfs();
5070         f2fs_destroy_garbage_collection_cache();
5071         f2fs_destroy_extent_cache();
5072         f2fs_destroy_recovery_cache();
5073         f2fs_destroy_checkpoint_caches();
5074         f2fs_destroy_segment_manager_caches();
5075         f2fs_destroy_node_manager_caches();
5076         destroy_inodecache();
5077 }
5078
5079 module_init(init_f2fs_fs)
5080 module_exit(exit_f2fs_fs)
5081
5082 MODULE_AUTHOR("Samsung Electronics's Praesto Team");
5083 MODULE_DESCRIPTION("Flash Friendly File System");
5084 MODULE_LICENSE("GPL");
5085 MODULE_SOFTDEP("pre: crc32");
5086