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