blob: 0c901a4d3d445a02b4973d2fef0c9db1c44b26f3 [file] [log] [blame]
Chao Yu7c1a0002018-09-12 09:16:07 +08001// SPDX-License-Identifier: GPL-2.0
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +09002/*
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003 * fs/f2fs/super.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09007 */
8#include <linux/module.h>
9#include <linux/init.h>
10#include <linux/fs.h>
11#include <linux/statfs.h>
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090012#include <linux/buffer_head.h>
13#include <linux/backing-dev.h>
14#include <linux/kthread.h>
15#include <linux/parser.h>
16#include <linux/mount.h>
17#include <linux/seq_file.h>
Jaegeuk Kim5e176d52013-06-28 12:47:01 +090018#include <linux/proc_fs.h>
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090019#include <linux/random.h>
20#include <linux/exportfs.h>
Namjae Jeond3ee4562013-03-17 17:26:14 +090021#include <linux/blkdev.h>
Chao Yu0abd6752017-07-09 00:13:07 +080022#include <linux/quotaops.h>
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090023#include <linux/f2fs_fs.h>
Namjae Jeonb59d0ba2013-08-04 23:09:40 +090024#include <linux/sysfs.h>
Chao Yu4b2414d2017-08-08 10:54:31 +080025#include <linux/quota.h>
Daniel Rosenberg5aba5432019-07-23 16:05:28 -070026#include <linux/unicode.h>
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090027
28#include "f2fs.h"
29#include "node.h"
Jaegeuk Kim5ec4e492013-03-31 13:26:03 +090030#include "segment.h"
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090031#include "xattr.h"
Namjae Jeonb59d0ba2013-08-04 23:09:40 +090032#include "gc.h"
Jaegeuk Kimdb9f7c12014-12-17 20:04:08 -080033#include "trace.h"
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090034
Namjae Jeona2a4a7e2013-04-20 01:28:40 +090035#define CREATE_TRACE_POINTS
36#include <trace/events/f2fs.h>
37
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090038static struct kmem_cache *f2fs_inode_cachep;
39
Jaegeuk Kim73faec42016-04-29 15:34:32 -070040#ifdef CONFIG_F2FS_FAULT_INJECTION
Jaegeuk Kim2c63fea2016-04-29 15:49:56 -070041
Alexey Dobriyan19880e62018-11-24 12:06:42 +030042const char *f2fs_fault_name[FAULT_MAX] = {
Jaegeuk Kim2c63fea2016-04-29 15:49:56 -070043 [FAULT_KMALLOC] = "kmalloc",
Chao Yu628b3d12017-11-30 19:28:18 +080044 [FAULT_KVMALLOC] = "kvmalloc",
Jaegeuk Kimc41f3cc32016-04-29 16:17:09 -070045 [FAULT_PAGE_ALLOC] = "page alloc",
Chao Yu01eccef2017-10-28 16:52:30 +080046 [FAULT_PAGE_GET] = "page get",
Chao Yud62fe972017-10-28 16:52:31 +080047 [FAULT_ALLOC_BIO] = "alloc bio",
Jaegeuk Kimcb789422016-04-29 16:29:22 -070048 [FAULT_ALLOC_NID] = "alloc nid",
49 [FAULT_ORPHAN] = "orphan",
50 [FAULT_BLOCK] = "no more block",
51 [FAULT_DIR_DEPTH] = "too big dir depth",
Jaegeuk Kim53aa6bb2016-05-25 15:24:18 -070052 [FAULT_EVICT_INODE] = "evict_inode fail",
Jaegeuk Kim14b44d22017-03-09 15:24:24 -080053 [FAULT_TRUNCATE] = "truncate fail",
Chao Yu6f5c2ed2018-09-12 09:22:29 +080054 [FAULT_READ_IO] = "read IO error",
Chao Yu0f348022016-09-26 19:45:55 +080055 [FAULT_CHECKPOINT] = "checkpoint error",
Chao Yub83dcfe2018-08-06 20:30:18 +080056 [FAULT_DISCARD] = "discard error",
Chao Yu6f5c2ed2018-09-12 09:22:29 +080057 [FAULT_WRITE_IO] = "write IO error",
Jaegeuk Kim2c63fea2016-04-29 15:49:56 -070058};
Sheng Yong08796892016-05-16 12:38:50 +080059
Chao Yud4945002018-08-08 17:36:41 +080060void f2fs_build_fault_attr(struct f2fs_sb_info *sbi, unsigned int rate,
61 unsigned int type)
Sheng Yong08796892016-05-16 12:38:50 +080062{
Chao Yu63189b72018-03-08 14:22:56 +080063 struct f2fs_fault_info *ffi = &F2FS_OPTION(sbi).fault_info;
Chao Yu1ecc0c52016-09-23 21:30:09 +080064
Sheng Yong08796892016-05-16 12:38:50 +080065 if (rate) {
Chao Yu1ecc0c52016-09-23 21:30:09 +080066 atomic_set(&ffi->inject_ops, 0);
67 ffi->inject_rate = rate;
Sheng Yong08796892016-05-16 12:38:50 +080068 }
Chao Yud4945002018-08-08 17:36:41 +080069
70 if (type)
71 ffi->inject_type = type;
72
73 if (!rate && !type)
74 memset(ffi, 0, sizeof(struct f2fs_fault_info));
Sheng Yong08796892016-05-16 12:38:50 +080075}
Jaegeuk Kim73faec42016-04-29 15:34:32 -070076#endif
77
Jaegeuk Kim2658e502015-06-19 12:01:21 -070078/* f2fs-wide shrinker description */
79static struct shrinker f2fs_shrinker_info = {
80 .scan_objects = f2fs_shrink_scan,
81 .count_objects = f2fs_shrink_count,
82 .seeks = DEFAULT_SEEKS,
83};
84
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090085enum {
Namjae Jeon696c0182013-06-16 09:48:48 +090086 Opt_gc_background,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090087 Opt_disable_roll_forward,
Jaegeuk Kim2d834bf2015-01-23 18:33:46 -080088 Opt_norecovery,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090089 Opt_discard,
Chao Yu64058be2016-07-03 22:05:14 +080090 Opt_nodiscard,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090091 Opt_noheap,
Jaegeuk Kim7a20b8a2017-03-24 20:41:45 -040092 Opt_heap,
Kelly Anderson4058c512013-10-07 11:36:20 +090093 Opt_user_xattr,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090094 Opt_nouser_xattr,
Kelly Anderson4058c512013-10-07 11:36:20 +090095 Opt_acl,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090096 Opt_noacl,
97 Opt_active_logs,
98 Opt_disable_ext_identify,
Jaegeuk Kim444c5802013-08-08 15:16:22 +090099 Opt_inline_xattr,
Chao Yu23cf7212017-02-15 10:34:45 +0800100 Opt_noinline_xattr,
Chao Yu6afc6622017-09-06 21:59:50 +0800101 Opt_inline_xattr_size,
Huajun Li8274de72013-11-10 23:13:17 +0800102 Opt_inline_data,
Chao Yu5efd3c62014-09-24 18:16:13 +0800103 Opt_inline_dentry,
Chao Yu97c17942016-05-09 19:56:34 +0800104 Opt_noinline_dentry,
Jaegeuk Kim6b4afdd2014-04-02 15:34:36 +0900105 Opt_flush_merge,
Jaegeuk Kim69e9e422016-05-20 22:39:20 -0700106 Opt_noflush_merge,
Jaegeuk Kim0f7b2ab2014-07-23 09:57:31 -0700107 Opt_nobarrier,
Jaegeuk Kimd5053a342014-10-30 22:47:03 -0700108 Opt_fastboot,
Chao Yu89672152015-02-05 17:55:51 +0800109 Opt_extent_cache,
Jaegeuk Kim7daaea22015-06-25 17:43:04 -0700110 Opt_noextent_cache,
Wanpeng Li75342792015-03-24 10:20:27 +0800111 Opt_noinline_data,
Chao Yu343f40f2015-12-16 13:12:16 +0800112 Opt_data_flush,
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800113 Opt_reserve_root,
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800114 Opt_resgid,
115 Opt_resuid,
Jaegeuk Kim36abef42016-06-03 19:29:38 -0700116 Opt_mode,
Jaegeuk Kimec915382016-12-21 17:09:19 -0800117 Opt_io_size_bits,
Jaegeuk Kim73faec42016-04-29 15:34:32 -0700118 Opt_fault_injection,
Chao Yud4945002018-08-08 17:36:41 +0800119 Opt_fault_type,
Jaegeuk Kim6d94c742016-05-20 21:47:24 -0700120 Opt_lazytime,
121 Opt_nolazytime,
Chao Yu4b2414d2017-08-08 10:54:31 +0800122 Opt_quota,
123 Opt_noquota,
Chao Yu0abd6752017-07-09 00:13:07 +0800124 Opt_usrquota,
125 Opt_grpquota,
Chao Yu5c571322017-07-26 00:01:41 +0800126 Opt_prjquota,
Chao Yu4b2414d2017-08-08 10:54:31 +0800127 Opt_usrjquota,
128 Opt_grpjquota,
129 Opt_prjjquota,
130 Opt_offusrjquota,
131 Opt_offgrpjquota,
132 Opt_offprjjquota,
133 Opt_jqfmt_vfsold,
134 Opt_jqfmt_vfsv0,
135 Opt_jqfmt_vfsv1,
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900136 Opt_whint,
Jaegeuk Kim07939622018-02-18 08:50:49 -0800137 Opt_alloc,
Junling Zheng93cf93f2018-03-07 12:07:49 +0800138 Opt_fsync,
Sheng Yongff62af22018-03-15 18:51:42 +0800139 Opt_test_dummy_encryption,
Daniel Rosenberg4d3aed72019-05-29 17:49:06 -0700140 Opt_checkpoint_disable,
141 Opt_checkpoint_disable_cap,
142 Opt_checkpoint_disable_cap_perc,
143 Opt_checkpoint_enable,
Chao Yu4c8ff702019-11-01 18:07:14 +0800144 Opt_compress_algorithm,
145 Opt_compress_log_size,
146 Opt_compress_extension,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900147 Opt_err,
148};
149
150static match_table_t f2fs_tokens = {
Namjae Jeon696c0182013-06-16 09:48:48 +0900151 {Opt_gc_background, "background_gc=%s"},
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900152 {Opt_disable_roll_forward, "disable_roll_forward"},
Jaegeuk Kim2d834bf2015-01-23 18:33:46 -0800153 {Opt_norecovery, "norecovery"},
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900154 {Opt_discard, "discard"},
Chao Yu64058be2016-07-03 22:05:14 +0800155 {Opt_nodiscard, "nodiscard"},
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900156 {Opt_noheap, "no_heap"},
Jaegeuk Kim7a20b8a2017-03-24 20:41:45 -0400157 {Opt_heap, "heap"},
Kelly Anderson4058c512013-10-07 11:36:20 +0900158 {Opt_user_xattr, "user_xattr"},
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900159 {Opt_nouser_xattr, "nouser_xattr"},
Kelly Anderson4058c512013-10-07 11:36:20 +0900160 {Opt_acl, "acl"},
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900161 {Opt_noacl, "noacl"},
162 {Opt_active_logs, "active_logs=%u"},
163 {Opt_disable_ext_identify, "disable_ext_identify"},
Jaegeuk Kim444c5802013-08-08 15:16:22 +0900164 {Opt_inline_xattr, "inline_xattr"},
Chao Yu23cf7212017-02-15 10:34:45 +0800165 {Opt_noinline_xattr, "noinline_xattr"},
Chao Yu6afc6622017-09-06 21:59:50 +0800166 {Opt_inline_xattr_size, "inline_xattr_size=%u"},
Huajun Li8274de72013-11-10 23:13:17 +0800167 {Opt_inline_data, "inline_data"},
Chao Yu5efd3c62014-09-24 18:16:13 +0800168 {Opt_inline_dentry, "inline_dentry"},
Chao Yu97c17942016-05-09 19:56:34 +0800169 {Opt_noinline_dentry, "noinline_dentry"},
Jaegeuk Kim6b4afdd2014-04-02 15:34:36 +0900170 {Opt_flush_merge, "flush_merge"},
Jaegeuk Kim69e9e422016-05-20 22:39:20 -0700171 {Opt_noflush_merge, "noflush_merge"},
Jaegeuk Kim0f7b2ab2014-07-23 09:57:31 -0700172 {Opt_nobarrier, "nobarrier"},
Jaegeuk Kimd5053a342014-10-30 22:47:03 -0700173 {Opt_fastboot, "fastboot"},
Chao Yu89672152015-02-05 17:55:51 +0800174 {Opt_extent_cache, "extent_cache"},
Jaegeuk Kim7daaea22015-06-25 17:43:04 -0700175 {Opt_noextent_cache, "noextent_cache"},
Wanpeng Li75342792015-03-24 10:20:27 +0800176 {Opt_noinline_data, "noinline_data"},
Chao Yu343f40f2015-12-16 13:12:16 +0800177 {Opt_data_flush, "data_flush"},
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800178 {Opt_reserve_root, "reserve_root=%u"},
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800179 {Opt_resgid, "resgid=%u"},
180 {Opt_resuid, "resuid=%u"},
Jaegeuk Kim36abef42016-06-03 19:29:38 -0700181 {Opt_mode, "mode=%s"},
Jaegeuk Kimec915382016-12-21 17:09:19 -0800182 {Opt_io_size_bits, "io_bits=%u"},
Jaegeuk Kim73faec42016-04-29 15:34:32 -0700183 {Opt_fault_injection, "fault_injection=%u"},
Chao Yud4945002018-08-08 17:36:41 +0800184 {Opt_fault_type, "fault_type=%u"},
Jaegeuk Kim6d94c742016-05-20 21:47:24 -0700185 {Opt_lazytime, "lazytime"},
186 {Opt_nolazytime, "nolazytime"},
Chao Yu4b2414d2017-08-08 10:54:31 +0800187 {Opt_quota, "quota"},
188 {Opt_noquota, "noquota"},
Chao Yu0abd6752017-07-09 00:13:07 +0800189 {Opt_usrquota, "usrquota"},
190 {Opt_grpquota, "grpquota"},
Chao Yu5c571322017-07-26 00:01:41 +0800191 {Opt_prjquota, "prjquota"},
Chao Yu4b2414d2017-08-08 10:54:31 +0800192 {Opt_usrjquota, "usrjquota=%s"},
193 {Opt_grpjquota, "grpjquota=%s"},
194 {Opt_prjjquota, "prjjquota=%s"},
195 {Opt_offusrjquota, "usrjquota="},
196 {Opt_offgrpjquota, "grpjquota="},
197 {Opt_offprjjquota, "prjjquota="},
198 {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
199 {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
200 {Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900201 {Opt_whint, "whint_mode=%s"},
Jaegeuk Kim07939622018-02-18 08:50:49 -0800202 {Opt_alloc, "alloc_mode=%s"},
Junling Zheng93cf93f2018-03-07 12:07:49 +0800203 {Opt_fsync, "fsync_mode=%s"},
Sheng Yongff62af22018-03-15 18:51:42 +0800204 {Opt_test_dummy_encryption, "test_dummy_encryption"},
Daniel Rosenberg4d3aed72019-05-29 17:49:06 -0700205 {Opt_checkpoint_disable, "checkpoint=disable"},
206 {Opt_checkpoint_disable_cap, "checkpoint=disable:%u"},
207 {Opt_checkpoint_disable_cap_perc, "checkpoint=disable:%u%%"},
208 {Opt_checkpoint_enable, "checkpoint=enable"},
Chao Yu4c8ff702019-11-01 18:07:14 +0800209 {Opt_compress_algorithm, "compress_algorithm=%s"},
210 {Opt_compress_log_size, "compress_log_size=%u"},
211 {Opt_compress_extension, "compress_extension=%s"},
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900212 {Opt_err, NULL},
213};
214
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800215void f2fs_printk(struct f2fs_sb_info *sbi, const char *fmt, ...)
Namjae Jeona07ef782012-12-30 14:52:05 +0900216{
217 struct va_format vaf;
218 va_list args;
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800219 int level;
Namjae Jeona07ef782012-12-30 14:52:05 +0900220
221 va_start(args, fmt);
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800222
223 level = printk_get_level(fmt);
224 vaf.fmt = printk_skip_level(fmt);
Namjae Jeona07ef782012-12-30 14:52:05 +0900225 vaf.va = &args;
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800226 printk("%c%cF2FS-fs (%s): %pV\n",
227 KERN_SOH_ASCII, level, sbi->sb->s_id, &vaf);
228
Namjae Jeona07ef782012-12-30 14:52:05 +0900229 va_end(args);
230}
231
Daniel Rosenberg5aba5432019-07-23 16:05:28 -0700232#ifdef CONFIG_UNICODE
233static const struct f2fs_sb_encodings {
234 __u16 magic;
235 char *name;
236 char *version;
237} f2fs_sb_encoding_map[] = {
238 {F2FS_ENC_UTF8_12_1, "utf8", "12.1.0"},
239};
240
241static int f2fs_sb_read_encoding(const struct f2fs_super_block *sb,
242 const struct f2fs_sb_encodings **encoding,
243 __u16 *flags)
244{
245 __u16 magic = le16_to_cpu(sb->s_encoding);
246 int i;
247
248 for (i = 0; i < ARRAY_SIZE(f2fs_sb_encoding_map); i++)
249 if (magic == f2fs_sb_encoding_map[i].magic)
250 break;
251
252 if (i >= ARRAY_SIZE(f2fs_sb_encoding_map))
253 return -EINVAL;
254
255 *encoding = &f2fs_sb_encoding_map[i];
256 *flags = le16_to_cpu(sb->s_encoding_flags);
257
258 return 0;
259}
260#endif
261
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800262static inline void limit_reserve_root(struct f2fs_sb_info *sbi)
263{
Daniel Rosenberg9a9aeca2019-05-29 17:49:04 -0700264 block_t limit = min((sbi->user_block_count << 1) / 1000,
265 sbi->user_block_count - sbi->reserved_blocks);
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800266
267 /* limit is 0.2% */
Chao Yu63189b72018-03-08 14:22:56 +0800268 if (test_opt(sbi, RESERVE_ROOT) &&
269 F2FS_OPTION(sbi).root_reserved_blocks > limit) {
270 F2FS_OPTION(sbi).root_reserved_blocks = limit;
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800271 f2fs_info(sbi, "Reduce reserved blocks for root = %u",
272 F2FS_OPTION(sbi).root_reserved_blocks);
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800273 }
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800274 if (!test_opt(sbi, RESERVE_ROOT) &&
Chao Yu63189b72018-03-08 14:22:56 +0800275 (!uid_eq(F2FS_OPTION(sbi).s_resuid,
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800276 make_kuid(&init_user_ns, F2FS_DEF_RESUID)) ||
Chao Yu63189b72018-03-08 14:22:56 +0800277 !gid_eq(F2FS_OPTION(sbi).s_resgid,
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800278 make_kgid(&init_user_ns, F2FS_DEF_RESGID))))
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800279 f2fs_info(sbi, "Ignore s_resuid=%u, s_resgid=%u w/o reserve_root",
280 from_kuid_munged(&init_user_ns,
281 F2FS_OPTION(sbi).s_resuid),
282 from_kgid_munged(&init_user_ns,
283 F2FS_OPTION(sbi).s_resgid));
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800284}
285
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900286static void init_once(void *foo)
287{
288 struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;
289
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900290 inode_init_once(&fi->vfs_inode);
291}
292
Chao Yu4b2414d2017-08-08 10:54:31 +0800293#ifdef CONFIG_QUOTA
294static const char * const quotatypes[] = INITQFNAMES;
295#define QTYPE2NAME(t) (quotatypes[t])
296static int f2fs_set_qf_name(struct super_block *sb, int qtype,
297 substring_t *args)
298{
299 struct f2fs_sb_info *sbi = F2FS_SB(sb);
300 char *qname;
301 int ret = -EINVAL;
302
Chao Yu63189b72018-03-08 14:22:56 +0800303 if (sb_any_quota_loaded(sb) && !F2FS_OPTION(sbi).s_qf_names[qtype]) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800304 f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");
Chao Yu4b2414d2017-08-08 10:54:31 +0800305 return -EINVAL;
306 }
Chao Yu7beb01f2018-10-24 18:34:26 +0800307 if (f2fs_sb_has_quota_ino(sbi)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800308 f2fs_info(sbi, "QUOTA feature is enabled, so ignore qf_name");
Jaegeuk Kimea676732017-10-06 09:14:28 -0700309 return 0;
310 }
311
Chao Yu4b2414d2017-08-08 10:54:31 +0800312 qname = match_strdup(args);
313 if (!qname) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800314 f2fs_err(sbi, "Not enough memory for storing quotafile name");
Chengguang Xuf365c6c2019-01-01 21:33:11 +0800315 return -ENOMEM;
Chao Yu4b2414d2017-08-08 10:54:31 +0800316 }
Chao Yu63189b72018-03-08 14:22:56 +0800317 if (F2FS_OPTION(sbi).s_qf_names[qtype]) {
318 if (strcmp(F2FS_OPTION(sbi).s_qf_names[qtype], qname) == 0)
Chao Yu4b2414d2017-08-08 10:54:31 +0800319 ret = 0;
320 else
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800321 f2fs_err(sbi, "%s quota file already specified",
Chao Yu4b2414d2017-08-08 10:54:31 +0800322 QTYPE2NAME(qtype));
323 goto errout;
324 }
325 if (strchr(qname, '/')) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800326 f2fs_err(sbi, "quotafile must be on filesystem root");
Chao Yu4b2414d2017-08-08 10:54:31 +0800327 goto errout;
328 }
Chao Yu63189b72018-03-08 14:22:56 +0800329 F2FS_OPTION(sbi).s_qf_names[qtype] = qname;
Chao Yu4b2414d2017-08-08 10:54:31 +0800330 set_opt(sbi, QUOTA);
331 return 0;
332errout:
Jaegeuk Kim52225952018-12-13 18:38:33 -0800333 kvfree(qname);
Chao Yu4b2414d2017-08-08 10:54:31 +0800334 return ret;
335}
336
337static int f2fs_clear_qf_name(struct super_block *sb, int qtype)
338{
339 struct f2fs_sb_info *sbi = F2FS_SB(sb);
340
Chao Yu63189b72018-03-08 14:22:56 +0800341 if (sb_any_quota_loaded(sb) && F2FS_OPTION(sbi).s_qf_names[qtype]) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800342 f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");
Chao Yu4b2414d2017-08-08 10:54:31 +0800343 return -EINVAL;
344 }
Jaegeuk Kim52225952018-12-13 18:38:33 -0800345 kvfree(F2FS_OPTION(sbi).s_qf_names[qtype]);
Chao Yu63189b72018-03-08 14:22:56 +0800346 F2FS_OPTION(sbi).s_qf_names[qtype] = NULL;
Chao Yu4b2414d2017-08-08 10:54:31 +0800347 return 0;
348}
349
350static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
351{
352 /*
353 * We do the test below only for project quotas. 'usrquota' and
354 * 'grpquota' mount options are allowed even without quota feature
355 * to support legacy quotas in quota files.
356 */
Chao Yu7beb01f2018-10-24 18:34:26 +0800357 if (test_opt(sbi, PRJQUOTA) && !f2fs_sb_has_project_quota(sbi)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800358 f2fs_err(sbi, "Project quota feature not enabled. Cannot enable project quota enforcement.");
Chao Yu4b2414d2017-08-08 10:54:31 +0800359 return -1;
360 }
Chao Yu63189b72018-03-08 14:22:56 +0800361 if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||
362 F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||
363 F2FS_OPTION(sbi).s_qf_names[PRJQUOTA]) {
364 if (test_opt(sbi, USRQUOTA) &&
365 F2FS_OPTION(sbi).s_qf_names[USRQUOTA])
Chao Yu4b2414d2017-08-08 10:54:31 +0800366 clear_opt(sbi, USRQUOTA);
367
Chao Yu63189b72018-03-08 14:22:56 +0800368 if (test_opt(sbi, GRPQUOTA) &&
369 F2FS_OPTION(sbi).s_qf_names[GRPQUOTA])
Chao Yu4b2414d2017-08-08 10:54:31 +0800370 clear_opt(sbi, GRPQUOTA);
371
Chao Yu63189b72018-03-08 14:22:56 +0800372 if (test_opt(sbi, PRJQUOTA) &&
373 F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])
Chao Yu4b2414d2017-08-08 10:54:31 +0800374 clear_opt(sbi, PRJQUOTA);
375
376 if (test_opt(sbi, GRPQUOTA) || test_opt(sbi, USRQUOTA) ||
377 test_opt(sbi, PRJQUOTA)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800378 f2fs_err(sbi, "old and new quota format mixing");
Chao Yu4b2414d2017-08-08 10:54:31 +0800379 return -1;
380 }
381
Chao Yu63189b72018-03-08 14:22:56 +0800382 if (!F2FS_OPTION(sbi).s_jquota_fmt) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800383 f2fs_err(sbi, "journaled quota format not specified");
Chao Yu4b2414d2017-08-08 10:54:31 +0800384 return -1;
385 }
386 }
Jaegeuk Kimea676732017-10-06 09:14:28 -0700387
Chao Yu7beb01f2018-10-24 18:34:26 +0800388 if (f2fs_sb_has_quota_ino(sbi) && F2FS_OPTION(sbi).s_jquota_fmt) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800389 f2fs_info(sbi, "QUOTA feature is enabled, so ignore jquota_fmt");
Chao Yu63189b72018-03-08 14:22:56 +0800390 F2FS_OPTION(sbi).s_jquota_fmt = 0;
Jaegeuk Kimea676732017-10-06 09:14:28 -0700391 }
Chao Yu4b2414d2017-08-08 10:54:31 +0800392 return 0;
393}
394#endif
395
Namjae Jeon696c0182013-06-16 09:48:48 +0900396static int parse_options(struct super_block *sb, char *options)
397{
398 struct f2fs_sb_info *sbi = F2FS_SB(sb);
399 substring_t args[MAX_OPT_ARGS];
Chao Yu4c8ff702019-11-01 18:07:14 +0800400 unsigned char (*ext)[F2FS_EXTENSION_LEN];
Namjae Jeon696c0182013-06-16 09:48:48 +0900401 char *p, *name;
Chao Yu4c8ff702019-11-01 18:07:14 +0800402 int arg = 0, ext_cnt;
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800403 kuid_t uid;
404 kgid_t gid;
Chao Yu4b2414d2017-08-08 10:54:31 +0800405#ifdef CONFIG_QUOTA
406 int ret;
407#endif
Namjae Jeon696c0182013-06-16 09:48:48 +0900408
409 if (!options)
410 return 0;
411
412 while ((p = strsep(&options, ",")) != NULL) {
413 int token;
414 if (!*p)
415 continue;
416 /*
417 * Initialize args struct so we know whether arg was
418 * found; some options take optional arguments.
419 */
420 args[0].to = args[0].from = NULL;
421 token = match_token(p, f2fs_tokens, args);
422
423 switch (token) {
424 case Opt_gc_background:
425 name = match_strdup(&args[0]);
426
427 if (!name)
428 return -ENOMEM;
Jaegeuk Kim6aefd932015-10-05 11:02:54 -0700429 if (strlen(name) == 2 && !strncmp(name, "on", 2)) {
Chao Yubbbc34f2020-02-14 17:44:13 +0800430 F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ON;
Jaegeuk Kim6aefd932015-10-05 11:02:54 -0700431 } else if (strlen(name) == 3 && !strncmp(name, "off", 3)) {
Chao Yubbbc34f2020-02-14 17:44:13 +0800432 F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_OFF;
Jaegeuk Kim6aefd932015-10-05 11:02:54 -0700433 } else if (strlen(name) == 4 && !strncmp(name, "sync", 4)) {
Chao Yubbbc34f2020-02-14 17:44:13 +0800434 F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_SYNC;
Jaegeuk Kim6aefd932015-10-05 11:02:54 -0700435 } else {
Jaegeuk Kim52225952018-12-13 18:38:33 -0800436 kvfree(name);
Namjae Jeon696c0182013-06-16 09:48:48 +0900437 return -EINVAL;
438 }
Jaegeuk Kim52225952018-12-13 18:38:33 -0800439 kvfree(name);
Namjae Jeon696c0182013-06-16 09:48:48 +0900440 break;
441 case Opt_disable_roll_forward:
442 set_opt(sbi, DISABLE_ROLL_FORWARD);
443 break;
Jaegeuk Kim2d834bf2015-01-23 18:33:46 -0800444 case Opt_norecovery:
445 /* this option mounts f2fs with ro */
Chao Yua9117ec2020-02-14 17:45:11 +0800446 set_opt(sbi, NORECOVERY);
Jaegeuk Kim2d834bf2015-01-23 18:33:46 -0800447 if (!f2fs_readonly(sb))
448 return -EINVAL;
449 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900450 case Opt_discard:
Chao Yu7d20c8a2018-09-04 03:52:17 +0800451 set_opt(sbi, DISCARD);
Namjae Jeon696c0182013-06-16 09:48:48 +0900452 break;
Chao Yu64058be2016-07-03 22:05:14 +0800453 case Opt_nodiscard:
Chao Yu7beb01f2018-10-24 18:34:26 +0800454 if (f2fs_sb_has_blkzoned(sbi)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800455 f2fs_warn(sbi, "discard is required for zoned block devices");
Damien Le Moal96ba2de2016-10-28 17:45:03 +0900456 return -EINVAL;
457 }
Chao Yu64058be2016-07-03 22:05:14 +0800458 clear_opt(sbi, DISCARD);
Damien Le Moal487df612016-10-28 17:44:59 +0900459 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900460 case Opt_noheap:
461 set_opt(sbi, NOHEAP);
462 break;
Jaegeuk Kim7a20b8a2017-03-24 20:41:45 -0400463 case Opt_heap:
464 clear_opt(sbi, NOHEAP);
465 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900466#ifdef CONFIG_F2FS_FS_XATTR
Kelly Anderson4058c512013-10-07 11:36:20 +0900467 case Opt_user_xattr:
468 set_opt(sbi, XATTR_USER);
469 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900470 case Opt_nouser_xattr:
471 clear_opt(sbi, XATTR_USER);
472 break;
Jaegeuk Kim444c5802013-08-08 15:16:22 +0900473 case Opt_inline_xattr:
474 set_opt(sbi, INLINE_XATTR);
475 break;
Chao Yu23cf7212017-02-15 10:34:45 +0800476 case Opt_noinline_xattr:
477 clear_opt(sbi, INLINE_XATTR);
478 break;
Chao Yu6afc6622017-09-06 21:59:50 +0800479 case Opt_inline_xattr_size:
480 if (args->from && match_int(args, &arg))
481 return -EINVAL;
482 set_opt(sbi, INLINE_XATTR_SIZE);
Chao Yu63189b72018-03-08 14:22:56 +0800483 F2FS_OPTION(sbi).inline_xattr_size = arg;
Chao Yu6afc6622017-09-06 21:59:50 +0800484 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900485#else
Kelly Anderson4058c512013-10-07 11:36:20 +0900486 case Opt_user_xattr:
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800487 f2fs_info(sbi, "user_xattr options not supported");
Kelly Anderson4058c512013-10-07 11:36:20 +0900488 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900489 case Opt_nouser_xattr:
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800490 f2fs_info(sbi, "nouser_xattr options not supported");
Namjae Jeon696c0182013-06-16 09:48:48 +0900491 break;
Jaegeuk Kim444c5802013-08-08 15:16:22 +0900492 case Opt_inline_xattr:
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800493 f2fs_info(sbi, "inline_xattr options not supported");
Jaegeuk Kim444c5802013-08-08 15:16:22 +0900494 break;
Chao Yu23cf7212017-02-15 10:34:45 +0800495 case Opt_noinline_xattr:
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800496 f2fs_info(sbi, "noinline_xattr options not supported");
Chao Yu23cf7212017-02-15 10:34:45 +0800497 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900498#endif
499#ifdef CONFIG_F2FS_FS_POSIX_ACL
Kelly Anderson4058c512013-10-07 11:36:20 +0900500 case Opt_acl:
501 set_opt(sbi, POSIX_ACL);
502 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900503 case Opt_noacl:
504 clear_opt(sbi, POSIX_ACL);
505 break;
506#else
Kelly Anderson4058c512013-10-07 11:36:20 +0900507 case Opt_acl:
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800508 f2fs_info(sbi, "acl options not supported");
Kelly Anderson4058c512013-10-07 11:36:20 +0900509 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900510 case Opt_noacl:
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800511 f2fs_info(sbi, "noacl options not supported");
Namjae Jeon696c0182013-06-16 09:48:48 +0900512 break;
513#endif
514 case Opt_active_logs:
515 if (args->from && match_int(args, &arg))
516 return -EINVAL;
517 if (arg != 2 && arg != 4 && arg != NR_CURSEG_TYPE)
518 return -EINVAL;
Chao Yu63189b72018-03-08 14:22:56 +0800519 F2FS_OPTION(sbi).active_logs = arg;
Namjae Jeon696c0182013-06-16 09:48:48 +0900520 break;
521 case Opt_disable_ext_identify:
522 set_opt(sbi, DISABLE_EXT_IDENTIFY);
523 break;
Huajun Li8274de72013-11-10 23:13:17 +0800524 case Opt_inline_data:
525 set_opt(sbi, INLINE_DATA);
526 break;
Chao Yu5efd3c62014-09-24 18:16:13 +0800527 case Opt_inline_dentry:
528 set_opt(sbi, INLINE_DENTRY);
529 break;
Chao Yu97c17942016-05-09 19:56:34 +0800530 case Opt_noinline_dentry:
531 clear_opt(sbi, INLINE_DENTRY);
532 break;
Jaegeuk Kim6b4afdd2014-04-02 15:34:36 +0900533 case Opt_flush_merge:
534 set_opt(sbi, FLUSH_MERGE);
535 break;
Jaegeuk Kim69e9e422016-05-20 22:39:20 -0700536 case Opt_noflush_merge:
537 clear_opt(sbi, FLUSH_MERGE);
538 break;
Jaegeuk Kim0f7b2ab2014-07-23 09:57:31 -0700539 case Opt_nobarrier:
540 set_opt(sbi, NOBARRIER);
541 break;
Jaegeuk Kimd5053a342014-10-30 22:47:03 -0700542 case Opt_fastboot:
543 set_opt(sbi, FASTBOOT);
544 break;
Chao Yu89672152015-02-05 17:55:51 +0800545 case Opt_extent_cache:
546 set_opt(sbi, EXTENT_CACHE);
547 break;
Jaegeuk Kim7daaea22015-06-25 17:43:04 -0700548 case Opt_noextent_cache:
549 clear_opt(sbi, EXTENT_CACHE);
550 break;
Wanpeng Li75342792015-03-24 10:20:27 +0800551 case Opt_noinline_data:
552 clear_opt(sbi, INLINE_DATA);
553 break;
Chao Yu343f40f2015-12-16 13:12:16 +0800554 case Opt_data_flush:
555 set_opt(sbi, DATA_FLUSH);
556 break;
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800557 case Opt_reserve_root:
558 if (args->from && match_int(args, &arg))
559 return -EINVAL;
560 if (test_opt(sbi, RESERVE_ROOT)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800561 f2fs_info(sbi, "Preserve previous reserve_root=%u",
562 F2FS_OPTION(sbi).root_reserved_blocks);
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800563 } else {
Chao Yu63189b72018-03-08 14:22:56 +0800564 F2FS_OPTION(sbi).root_reserved_blocks = arg;
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800565 set_opt(sbi, RESERVE_ROOT);
566 }
567 break;
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800568 case Opt_resuid:
569 if (args->from && match_int(args, &arg))
570 return -EINVAL;
571 uid = make_kuid(current_user_ns(), arg);
572 if (!uid_valid(uid)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800573 f2fs_err(sbi, "Invalid uid value %d", arg);
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800574 return -EINVAL;
575 }
Chao Yu63189b72018-03-08 14:22:56 +0800576 F2FS_OPTION(sbi).s_resuid = uid;
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800577 break;
578 case Opt_resgid:
579 if (args->from && match_int(args, &arg))
580 return -EINVAL;
581 gid = make_kgid(current_user_ns(), arg);
582 if (!gid_valid(gid)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800583 f2fs_err(sbi, "Invalid gid value %d", arg);
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800584 return -EINVAL;
585 }
Chao Yu63189b72018-03-08 14:22:56 +0800586 F2FS_OPTION(sbi).s_resgid = gid;
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800587 break;
Jaegeuk Kim36abef42016-06-03 19:29:38 -0700588 case Opt_mode:
589 name = match_strdup(&args[0]);
590
591 if (!name)
592 return -ENOMEM;
593 if (strlen(name) == 8 &&
594 !strncmp(name, "adaptive", 8)) {
Chao Yu7beb01f2018-10-24 18:34:26 +0800595 if (f2fs_sb_has_blkzoned(sbi)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800596 f2fs_warn(sbi, "adaptive mode is not allowed with zoned block device feature");
Jaegeuk Kim52225952018-12-13 18:38:33 -0800597 kvfree(name);
Damien Le Moal3adc57e2016-10-28 17:45:04 +0900598 return -EINVAL;
599 }
Chao Yub0332a02020-02-14 17:44:12 +0800600 F2FS_OPTION(sbi).fs_mode = FS_MODE_ADAPTIVE;
Jaegeuk Kim36abef42016-06-03 19:29:38 -0700601 } else if (strlen(name) == 3 &&
602 !strncmp(name, "lfs", 3)) {
Chao Yub0332a02020-02-14 17:44:12 +0800603 F2FS_OPTION(sbi).fs_mode = FS_MODE_LFS;
Jaegeuk Kim36abef42016-06-03 19:29:38 -0700604 } else {
Jaegeuk Kim52225952018-12-13 18:38:33 -0800605 kvfree(name);
Jaegeuk Kim36abef42016-06-03 19:29:38 -0700606 return -EINVAL;
607 }
Jaegeuk Kim52225952018-12-13 18:38:33 -0800608 kvfree(name);
Jaegeuk Kim36abef42016-06-03 19:29:38 -0700609 break;
Jaegeuk Kimec915382016-12-21 17:09:19 -0800610 case Opt_io_size_bits:
611 if (args->from && match_int(args, &arg))
612 return -EINVAL;
Chao Yu6d52e132019-02-15 00:16:15 +0800613 if (arg <= 0 || arg > __ilog2_u32(BIO_MAX_PAGES)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800614 f2fs_warn(sbi, "Not support %d, larger than %d",
615 1 << arg, BIO_MAX_PAGES);
Jaegeuk Kimec915382016-12-21 17:09:19 -0800616 return -EINVAL;
617 }
Chao Yu63189b72018-03-08 14:22:56 +0800618 F2FS_OPTION(sbi).write_io_size_bits = arg;
Jaegeuk Kimec915382016-12-21 17:09:19 -0800619 break;
Chengguang Xu4cb037e2018-09-12 13:32:52 +0800620#ifdef CONFIG_F2FS_FAULT_INJECTION
Jaegeuk Kim73faec42016-04-29 15:34:32 -0700621 case Opt_fault_injection:
622 if (args->from && match_int(args, &arg))
623 return -EINVAL;
Chao Yud4945002018-08-08 17:36:41 +0800624 f2fs_build_fault_attr(sbi, arg, F2FS_ALL_FAULT_TYPE);
625 set_opt(sbi, FAULT_INJECTION);
Chao Yud4945002018-08-08 17:36:41 +0800626 break;
Chengguang Xu4cb037e2018-09-12 13:32:52 +0800627
Chao Yud4945002018-08-08 17:36:41 +0800628 case Opt_fault_type:
629 if (args->from && match_int(args, &arg))
630 return -EINVAL;
Chao Yud4945002018-08-08 17:36:41 +0800631 f2fs_build_fault_attr(sbi, 0, arg);
Kaixu Xia0cc0dec2017-01-27 09:35:37 +0800632 set_opt(sbi, FAULT_INJECTION);
Jaegeuk Kim73faec42016-04-29 15:34:32 -0700633 break;
Chengguang Xu4cb037e2018-09-12 13:32:52 +0800634#else
635 case Opt_fault_injection:
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800636 f2fs_info(sbi, "fault_injection options not supported");
Chengguang Xu4cb037e2018-09-12 13:32:52 +0800637 break;
638
639 case Opt_fault_type:
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800640 f2fs_info(sbi, "fault_type options not supported");
Chengguang Xu4cb037e2018-09-12 13:32:52 +0800641 break;
642#endif
Jaegeuk Kim6d94c742016-05-20 21:47:24 -0700643 case Opt_lazytime:
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800644 sb->s_flags |= SB_LAZYTIME;
Jaegeuk Kim6d94c742016-05-20 21:47:24 -0700645 break;
646 case Opt_nolazytime:
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800647 sb->s_flags &= ~SB_LAZYTIME;
Jaegeuk Kim6d94c742016-05-20 21:47:24 -0700648 break;
Chao Yu0abd6752017-07-09 00:13:07 +0800649#ifdef CONFIG_QUOTA
Chao Yu4b2414d2017-08-08 10:54:31 +0800650 case Opt_quota:
Chao Yu0abd6752017-07-09 00:13:07 +0800651 case Opt_usrquota:
652 set_opt(sbi, USRQUOTA);
653 break;
654 case Opt_grpquota:
655 set_opt(sbi, GRPQUOTA);
656 break;
Chao Yu5c571322017-07-26 00:01:41 +0800657 case Opt_prjquota:
658 set_opt(sbi, PRJQUOTA);
659 break;
Chao Yu4b2414d2017-08-08 10:54:31 +0800660 case Opt_usrjquota:
661 ret = f2fs_set_qf_name(sb, USRQUOTA, &args[0]);
662 if (ret)
663 return ret;
664 break;
665 case Opt_grpjquota:
666 ret = f2fs_set_qf_name(sb, GRPQUOTA, &args[0]);
667 if (ret)
668 return ret;
669 break;
670 case Opt_prjjquota:
671 ret = f2fs_set_qf_name(sb, PRJQUOTA, &args[0]);
672 if (ret)
673 return ret;
674 break;
675 case Opt_offusrjquota:
676 ret = f2fs_clear_qf_name(sb, USRQUOTA);
677 if (ret)
678 return ret;
679 break;
680 case Opt_offgrpjquota:
681 ret = f2fs_clear_qf_name(sb, GRPQUOTA);
682 if (ret)
683 return ret;
684 break;
685 case Opt_offprjjquota:
686 ret = f2fs_clear_qf_name(sb, PRJQUOTA);
687 if (ret)
688 return ret;
689 break;
690 case Opt_jqfmt_vfsold:
Chao Yu63189b72018-03-08 14:22:56 +0800691 F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_OLD;
Chao Yu4b2414d2017-08-08 10:54:31 +0800692 break;
693 case Opt_jqfmt_vfsv0:
Chao Yu63189b72018-03-08 14:22:56 +0800694 F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V0;
Chao Yu4b2414d2017-08-08 10:54:31 +0800695 break;
696 case Opt_jqfmt_vfsv1:
Chao Yu63189b72018-03-08 14:22:56 +0800697 F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V1;
Chao Yu4b2414d2017-08-08 10:54:31 +0800698 break;
699 case Opt_noquota:
700 clear_opt(sbi, QUOTA);
701 clear_opt(sbi, USRQUOTA);
702 clear_opt(sbi, GRPQUOTA);
703 clear_opt(sbi, PRJQUOTA);
704 break;
Chao Yu0abd6752017-07-09 00:13:07 +0800705#else
Chao Yu4b2414d2017-08-08 10:54:31 +0800706 case Opt_quota:
Chao Yu0abd6752017-07-09 00:13:07 +0800707 case Opt_usrquota:
708 case Opt_grpquota:
Chao Yu5c571322017-07-26 00:01:41 +0800709 case Opt_prjquota:
Chao Yu4b2414d2017-08-08 10:54:31 +0800710 case Opt_usrjquota:
711 case Opt_grpjquota:
712 case Opt_prjjquota:
713 case Opt_offusrjquota:
714 case Opt_offgrpjquota:
715 case Opt_offprjjquota:
716 case Opt_jqfmt_vfsold:
717 case Opt_jqfmt_vfsv0:
718 case Opt_jqfmt_vfsv1:
719 case Opt_noquota:
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800720 f2fs_info(sbi, "quota operations not supported");
Chao Yu0abd6752017-07-09 00:13:07 +0800721 break;
722#endif
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900723 case Opt_whint:
724 name = match_strdup(&args[0]);
725 if (!name)
726 return -ENOMEM;
727 if (strlen(name) == 10 &&
728 !strncmp(name, "user-based", 10)) {
Chao Yu63189b72018-03-08 14:22:56 +0800729 F2FS_OPTION(sbi).whint_mode = WHINT_MODE_USER;
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900730 } else if (strlen(name) == 3 &&
731 !strncmp(name, "off", 3)) {
Chao Yu63189b72018-03-08 14:22:56 +0800732 F2FS_OPTION(sbi).whint_mode = WHINT_MODE_OFF;
Hyunchul Leef2e703f2018-01-31 11:36:58 +0900733 } else if (strlen(name) == 8 &&
734 !strncmp(name, "fs-based", 8)) {
Chao Yu63189b72018-03-08 14:22:56 +0800735 F2FS_OPTION(sbi).whint_mode = WHINT_MODE_FS;
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900736 } else {
Jaegeuk Kim52225952018-12-13 18:38:33 -0800737 kvfree(name);
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900738 return -EINVAL;
739 }
Jaegeuk Kim52225952018-12-13 18:38:33 -0800740 kvfree(name);
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900741 break;
Jaegeuk Kim07939622018-02-18 08:50:49 -0800742 case Opt_alloc:
743 name = match_strdup(&args[0]);
744 if (!name)
745 return -ENOMEM;
746
747 if (strlen(name) == 7 &&
748 !strncmp(name, "default", 7)) {
Chao Yu63189b72018-03-08 14:22:56 +0800749 F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;
Jaegeuk Kim07939622018-02-18 08:50:49 -0800750 } else if (strlen(name) == 5 &&
751 !strncmp(name, "reuse", 5)) {
Chao Yu63189b72018-03-08 14:22:56 +0800752 F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
Jaegeuk Kim07939622018-02-18 08:50:49 -0800753 } else {
Jaegeuk Kim52225952018-12-13 18:38:33 -0800754 kvfree(name);
Jaegeuk Kim07939622018-02-18 08:50:49 -0800755 return -EINVAL;
756 }
Jaegeuk Kim52225952018-12-13 18:38:33 -0800757 kvfree(name);
Jaegeuk Kim07939622018-02-18 08:50:49 -0800758 break;
Junling Zheng93cf93f2018-03-07 12:07:49 +0800759 case Opt_fsync:
760 name = match_strdup(&args[0]);
761 if (!name)
762 return -ENOMEM;
763 if (strlen(name) == 5 &&
764 !strncmp(name, "posix", 5)) {
Chao Yu63189b72018-03-08 14:22:56 +0800765 F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;
Junling Zheng93cf93f2018-03-07 12:07:49 +0800766 } else if (strlen(name) == 6 &&
767 !strncmp(name, "strict", 6)) {
Chao Yu63189b72018-03-08 14:22:56 +0800768 F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_STRICT;
Jaegeuk Kimd6290812018-05-25 18:02:58 -0700769 } else if (strlen(name) == 9 &&
770 !strncmp(name, "nobarrier", 9)) {
771 F2FS_OPTION(sbi).fsync_mode =
772 FSYNC_MODE_NOBARRIER;
Junling Zheng93cf93f2018-03-07 12:07:49 +0800773 } else {
Jaegeuk Kim52225952018-12-13 18:38:33 -0800774 kvfree(name);
Junling Zheng93cf93f2018-03-07 12:07:49 +0800775 return -EINVAL;
776 }
Jaegeuk Kim52225952018-12-13 18:38:33 -0800777 kvfree(name);
Junling Zheng93cf93f2018-03-07 12:07:49 +0800778 break;
Sheng Yongff62af22018-03-15 18:51:42 +0800779 case Opt_test_dummy_encryption:
Chandan Rajendra643fa962018-12-12 15:20:12 +0530780#ifdef CONFIG_FS_ENCRYPTION
Chao Yu7beb01f2018-10-24 18:34:26 +0800781 if (!f2fs_sb_has_encrypt(sbi)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800782 f2fs_err(sbi, "Encrypt feature is off");
Sheng Yongff62af22018-03-15 18:51:42 +0800783 return -EINVAL;
784 }
785
786 F2FS_OPTION(sbi).test_dummy_encryption = true;
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800787 f2fs_info(sbi, "Test dummy encryption mode enabled");
Sheng Yongff62af22018-03-15 18:51:42 +0800788#else
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800789 f2fs_info(sbi, "Test dummy encryption mount option ignored");
Sheng Yongff62af22018-03-15 18:51:42 +0800790#endif
791 break;
Daniel Rosenberg4d3aed72019-05-29 17:49:06 -0700792 case Opt_checkpoint_disable_cap_perc:
793 if (args->from && match_int(args, &arg))
Daniel Rosenberg43549942018-08-20 19:21:43 -0700794 return -EINVAL;
Daniel Rosenberg4d3aed72019-05-29 17:49:06 -0700795 if (arg < 0 || arg > 100)
796 return -EINVAL;
797 if (arg == 100)
798 F2FS_OPTION(sbi).unusable_cap =
799 sbi->user_block_count;
800 else
801 F2FS_OPTION(sbi).unusable_cap =
802 (sbi->user_block_count / 100) * arg;
803 set_opt(sbi, DISABLE_CHECKPOINT);
804 break;
805 case Opt_checkpoint_disable_cap:
806 if (args->from && match_int(args, &arg))
807 return -EINVAL;
808 F2FS_OPTION(sbi).unusable_cap = arg;
809 set_opt(sbi, DISABLE_CHECKPOINT);
810 break;
811 case Opt_checkpoint_disable:
812 set_opt(sbi, DISABLE_CHECKPOINT);
813 break;
814 case Opt_checkpoint_enable:
815 clear_opt(sbi, DISABLE_CHECKPOINT);
Daniel Rosenberg43549942018-08-20 19:21:43 -0700816 break;
Chao Yu4c8ff702019-11-01 18:07:14 +0800817 case Opt_compress_algorithm:
818 if (!f2fs_sb_has_compression(sbi)) {
819 f2fs_err(sbi, "Compression feature if off");
820 return -EINVAL;
821 }
822 name = match_strdup(&args[0]);
823 if (!name)
824 return -ENOMEM;
825 if (strlen(name) == 3 && !strcmp(name, "lzo")) {
826 F2FS_OPTION(sbi).compress_algorithm =
827 COMPRESS_LZO;
828 } else if (strlen(name) == 3 &&
829 !strcmp(name, "lz4")) {
830 F2FS_OPTION(sbi).compress_algorithm =
831 COMPRESS_LZ4;
832 } else {
833 kfree(name);
834 return -EINVAL;
835 }
836 kfree(name);
837 break;
838 case Opt_compress_log_size:
839 if (!f2fs_sb_has_compression(sbi)) {
840 f2fs_err(sbi, "Compression feature is off");
841 return -EINVAL;
842 }
843 if (args->from && match_int(args, &arg))
844 return -EINVAL;
845 if (arg < MIN_COMPRESS_LOG_SIZE ||
846 arg > MAX_COMPRESS_LOG_SIZE) {
847 f2fs_err(sbi,
848 "Compress cluster log size is out of range");
849 return -EINVAL;
850 }
851 F2FS_OPTION(sbi).compress_log_size = arg;
852 break;
853 case Opt_compress_extension:
854 if (!f2fs_sb_has_compression(sbi)) {
855 f2fs_err(sbi, "Compression feature is off");
856 return -EINVAL;
857 }
858 name = match_strdup(&args[0]);
859 if (!name)
860 return -ENOMEM;
861
862 ext = F2FS_OPTION(sbi).extensions;
863 ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;
864
865 if (strlen(name) >= F2FS_EXTENSION_LEN ||
866 ext_cnt >= COMPRESS_EXT_NUM) {
867 f2fs_err(sbi,
868 "invalid extension length/number");
869 kfree(name);
870 return -EINVAL;
871 }
872
873 strcpy(ext[ext_cnt], name);
874 F2FS_OPTION(sbi).compress_ext_cnt++;
875 kfree(name);
876 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900877 default:
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800878 f2fs_err(sbi, "Unrecognized mount option \"%s\" or missing value",
879 p);
Namjae Jeon696c0182013-06-16 09:48:48 +0900880 return -EINVAL;
881 }
882 }
Chao Yu4b2414d2017-08-08 10:54:31 +0800883#ifdef CONFIG_QUOTA
884 if (f2fs_check_quota_options(sbi))
885 return -EINVAL;
Sheng Yong00960c22018-07-24 20:17:52 +0800886#else
Chao Yu7beb01f2018-10-24 18:34:26 +0800887 if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sbi->sb)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800888 f2fs_info(sbi, "Filesystem with quota feature cannot be mounted RDWR without CONFIG_QUOTA");
Sheng Yong00960c22018-07-24 20:17:52 +0800889 return -EINVAL;
890 }
Chao Yu7beb01f2018-10-24 18:34:26 +0800891 if (f2fs_sb_has_project_quota(sbi) && !f2fs_readonly(sbi->sb)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800892 f2fs_err(sbi, "Filesystem with project quota feature cannot be mounted RDWR without CONFIG_QUOTA");
Chao Yu4ddc1b22018-07-26 07:19:48 +0800893 return -EINVAL;
894 }
Chao Yu4b2414d2017-08-08 10:54:31 +0800895#endif
Daniel Rosenberg5aba5432019-07-23 16:05:28 -0700896#ifndef CONFIG_UNICODE
897 if (f2fs_sb_has_casefold(sbi)) {
898 f2fs_err(sbi,
899 "Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");
900 return -EINVAL;
901 }
902#endif
Jaegeuk Kimec915382016-12-21 17:09:19 -0800903
Chao Yub0332a02020-02-14 17:44:12 +0800904 if (F2FS_IO_SIZE_BITS(sbi) && !f2fs_lfs_mode(sbi)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800905 f2fs_err(sbi, "Should set mode=lfs with %uKB-sized IO",
906 F2FS_IO_SIZE_KB(sbi));
Jaegeuk Kimec915382016-12-21 17:09:19 -0800907 return -EINVAL;
908 }
Chao Yu6afc6622017-09-06 21:59:50 +0800909
910 if (test_opt(sbi, INLINE_XATTR_SIZE)) {
Jaegeuk Kim70db5b02019-03-12 11:49:53 -0700911 int min_size, max_size;
912
Chao Yu7beb01f2018-10-24 18:34:26 +0800913 if (!f2fs_sb_has_extra_attr(sbi) ||
914 !f2fs_sb_has_flexible_inline_xattr(sbi)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800915 f2fs_err(sbi, "extra_attr or flexible_inline_xattr feature is off");
Chao Yu4d817ae2018-01-27 17:29:48 +0800916 return -EINVAL;
917 }
Chao Yu6afc6622017-09-06 21:59:50 +0800918 if (!test_opt(sbi, INLINE_XATTR)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800919 f2fs_err(sbi, "inline_xattr_size option should be set with inline_xattr option");
Chao Yu6afc6622017-09-06 21:59:50 +0800920 return -EINVAL;
921 }
Jaegeuk Kim70db5b02019-03-12 11:49:53 -0700922
923 min_size = sizeof(struct f2fs_xattr_header) / sizeof(__le32);
Chao Yudd6c89b2019-03-04 17:19:04 +0800924 max_size = MAX_INLINE_XATTR_SIZE;
Jaegeuk Kim70db5b02019-03-12 11:49:53 -0700925
926 if (F2FS_OPTION(sbi).inline_xattr_size < min_size ||
927 F2FS_OPTION(sbi).inline_xattr_size > max_size) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800928 f2fs_err(sbi, "inline xattr size is out of range: %d ~ %d",
929 min_size, max_size);
Chao Yu6afc6622017-09-06 21:59:50 +0800930 return -EINVAL;
931 }
932 }
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900933
Chao Yub0332a02020-02-14 17:44:12 +0800934 if (test_opt(sbi, DISABLE_CHECKPOINT) && f2fs_lfs_mode(sbi)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800935 f2fs_err(sbi, "LFS not compatible with checkpoint=disable\n");
Daniel Rosenberg43549942018-08-20 19:21:43 -0700936 return -EINVAL;
937 }
938
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900939 /* Not pass down write hints if the number of active logs is lesser
940 * than NR_CURSEG_TYPE.
941 */
Chao Yu63189b72018-03-08 14:22:56 +0800942 if (F2FS_OPTION(sbi).active_logs != NR_CURSEG_TYPE)
943 F2FS_OPTION(sbi).whint_mode = WHINT_MODE_OFF;
Namjae Jeon696c0182013-06-16 09:48:48 +0900944 return 0;
945}
946
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900947static struct inode *f2fs_alloc_inode(struct super_block *sb)
948{
949 struct f2fs_inode_info *fi;
950
Chao Yua0acdfe2013-12-05 09:54:00 +0800951 fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_F2FS_ZERO);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900952 if (!fi)
953 return NULL;
954
955 init_once((void *) fi);
956
Masanari Iida434720f2013-03-19 08:03:35 +0900957 /* Initialize f2fs-specific inode info */
Jaegeuk Kim204706c2016-12-02 15:11:32 -0800958 atomic_set(&fi->dirty_pages, 0);
Jaegeuk Kimd928bfb2014-03-20 19:10:08 +0900959 init_rwsem(&fi->i_sem);
Chao Yuc10c9822020-02-27 19:30:03 +0800960 spin_lock_init(&fi->i_size_lock);
Chao Yu2710fd72015-12-15 13:30:45 +0800961 INIT_LIST_HEAD(&fi->dirty_list);
Jaegeuk Kim0f18b462016-05-20 11:10:10 -0700962 INIT_LIST_HEAD(&fi->gdirty_list);
Jaegeuk Kim57864ae2017-10-18 19:05:57 -0700963 INIT_LIST_HEAD(&fi->inmem_ilist);
Jaegeuk Kim88b88a62014-10-06 17:39:50 -0700964 INIT_LIST_HEAD(&fi->inmem_pages);
965 mutex_init(&fi->inmem_lock);
Chao Yub2532c62018-04-24 10:55:28 +0800966 init_rwsem(&fi->i_gc_rwsem[READ]);
967 init_rwsem(&fi->i_gc_rwsem[WRITE]);
Qiuyang Sun5a3a2d82017-05-18 11:06:45 +0800968 init_rwsem(&fi->i_mmap_sem);
Yunlei He27161f12017-09-07 10:40:54 +0800969 init_rwsem(&fi->i_xattr_sem);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900970
Jaegeuk Kimab9fa662014-02-27 20:09:05 +0900971 /* Will be used by directory only */
972 fi->i_dir_level = F2FS_SB(sb)->dir_level;
Chao Yuf2470372017-07-19 00:19:05 +0800973
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900974 return &fi->vfs_inode;
975}
976
Jaegeuk Kim531ad7d2013-04-30 11:33:27 +0900977static int f2fs_drop_inode(struct inode *inode)
978{
Chao Yua8933b62019-07-18 16:39:59 +0800979 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Hou Pengyangb8d96a32017-02-27 13:02:58 +0000980 int ret;
Chao Yua8933b62019-07-18 16:39:59 +0800981
982 /*
983 * during filesystem shutdown, if checkpoint is disabled,
984 * drop useless meta/node dirty pages.
985 */
986 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
987 if (inode->i_ino == F2FS_NODE_INO(sbi) ||
988 inode->i_ino == F2FS_META_INO(sbi)) {
989 trace_f2fs_drop_inode(inode, 1);
990 return 1;
991 }
992 }
993
Jaegeuk Kim531ad7d2013-04-30 11:33:27 +0900994 /*
995 * This is to avoid a deadlock condition like below.
996 * writeback_single_inode(inode)
997 * - f2fs_write_data_page
998 * - f2fs_gc -> iput -> evict
999 * - inode_wait_for_writeback(inode)
1000 */
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001001 if ((!inode_unhashed(inode) && inode->i_state & I_SYNC)) {
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -07001002 if (!inode->i_nlink && !is_bad_inode(inode)) {
Jaegeuk Kim3e72f722015-06-19 17:53:26 -07001003 /* to avoid evict_inode call simultaneously */
1004 atomic_inc(&inode->i_count);
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -07001005 spin_unlock(&inode->i_lock);
1006
1007 /* some remained atomic pages should discarded */
1008 if (f2fs_is_atomic_file(inode))
Chao Yu4d57b862018-05-30 00:20:41 +08001009 f2fs_drop_inmem_pages(inode);
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -07001010
Jaegeuk Kim3e72f722015-06-19 17:53:26 -07001011 /* should remain fi->extent_tree for writepage */
1012 f2fs_destroy_extent_node(inode);
1013
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -07001014 sb_start_intwrite(inode->i_sb);
Jaegeuk Kimfc9581c2016-05-20 09:22:03 -07001015 f2fs_i_size_write(inode, 0);
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -07001016
zhenglianga0770e12019-03-04 09:32:25 +08001017 f2fs_submit_merged_write_cond(F2FS_I_SB(inode),
1018 inode, NULL, 0, DATA);
1019 truncate_inode_pages_final(inode->i_mapping);
1020
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -07001021 if (F2FS_HAS_BLOCKS(inode))
Jaegeuk Kim9a449e92016-06-02 13:49:38 -07001022 f2fs_truncate(inode);
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -07001023
1024 sb_end_intwrite(inode->i_sb);
1025
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -07001026 spin_lock(&inode->i_lock);
Jaegeuk Kim3e72f722015-06-19 17:53:26 -07001027 atomic_dec(&inode->i_count);
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -07001028 }
Hou Pengyangb8d96a32017-02-27 13:02:58 +00001029 trace_f2fs_drop_inode(inode, 0);
Jaegeuk Kim531ad7d2013-04-30 11:33:27 +09001030 return 0;
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -07001031 }
Hou Pengyangb8d96a32017-02-27 13:02:58 +00001032 ret = generic_drop_inode(inode);
Eric Biggers8ce589c2019-08-04 19:35:48 -07001033 if (!ret)
1034 ret = fscrypt_drop_inode(inode);
Hou Pengyangb8d96a32017-02-27 13:02:58 +00001035 trace_f2fs_drop_inode(inode, ret);
1036 return ret;
Jaegeuk Kim531ad7d2013-04-30 11:33:27 +09001037}
1038
Jaegeuk Kim7c457292016-10-14 11:51:23 -07001039int f2fs_inode_dirtied(struct inode *inode, bool sync)
Jaegeuk Kimb56ab832016-06-30 19:09:37 -07001040{
1041 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Jaegeuk Kim7c457292016-10-14 11:51:23 -07001042 int ret = 0;
Jaegeuk Kimb56ab832016-06-30 19:09:37 -07001043
1044 spin_lock(&sbi->inode_lock[DIRTY_META]);
1045 if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
Jaegeuk Kim7c457292016-10-14 11:51:23 -07001046 ret = 1;
1047 } else {
1048 set_inode_flag(inode, FI_DIRTY_INODE);
1049 stat_inc_dirty_inode(sbi, DIRTY_META);
Jaegeuk Kimb56ab832016-06-30 19:09:37 -07001050 }
Jaegeuk Kim7c457292016-10-14 11:51:23 -07001051 if (sync && list_empty(&F2FS_I(inode)->gdirty_list)) {
1052 list_add_tail(&F2FS_I(inode)->gdirty_list,
Jaegeuk Kimb56ab832016-06-30 19:09:37 -07001053 &sbi->inode_list[DIRTY_META]);
Jaegeuk Kim7c457292016-10-14 11:51:23 -07001054 inc_page_count(sbi, F2FS_DIRTY_IMETA);
1055 }
Jaegeuk Kimb56ab832016-06-30 19:09:37 -07001056 spin_unlock(&sbi->inode_lock[DIRTY_META]);
Jaegeuk Kim7c457292016-10-14 11:51:23 -07001057 return ret;
Jaegeuk Kimb56ab832016-06-30 19:09:37 -07001058}
1059
1060void f2fs_inode_synced(struct inode *inode)
1061{
1062 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1063
1064 spin_lock(&sbi->inode_lock[DIRTY_META]);
1065 if (!is_inode_flag_set(inode, FI_DIRTY_INODE)) {
1066 spin_unlock(&sbi->inode_lock[DIRTY_META]);
1067 return;
1068 }
Jaegeuk Kim7c457292016-10-14 11:51:23 -07001069 if (!list_empty(&F2FS_I(inode)->gdirty_list)) {
1070 list_del_init(&F2FS_I(inode)->gdirty_list);
1071 dec_page_count(sbi, F2FS_DIRTY_IMETA);
1072 }
Jaegeuk Kimb56ab832016-06-30 19:09:37 -07001073 clear_inode_flag(inode, FI_DIRTY_INODE);
1074 clear_inode_flag(inode, FI_AUTO_RECOVER);
Jaegeuk Kimb56ab832016-06-30 19:09:37 -07001075 stat_dec_dirty_inode(F2FS_I_SB(inode), DIRTY_META);
1076 spin_unlock(&sbi->inode_lock[DIRTY_META]);
1077}
1078
Jaegeuk Kimb3783872013-06-10 09:17:01 +09001079/*
1080 * f2fs_dirty_inode() is called from __mark_inode_dirty()
1081 *
1082 * We should call set_dirty_inode to write the dirty inode through write_inode.
1083 */
1084static void f2fs_dirty_inode(struct inode *inode, int flags)
1085{
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001086 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1087
1088 if (inode->i_ino == F2FS_NODE_INO(sbi) ||
1089 inode->i_ino == F2FS_META_INO(sbi))
1090 return;
1091
Jaegeuk Kim6d94c742016-05-20 21:47:24 -07001092 if (flags == I_DIRTY_TIME)
1093 return;
1094
Jaegeuk Kim26de9b12016-05-20 20:42:37 -07001095 if (is_inode_flag_set(inode, FI_AUTO_RECOVER))
1096 clear_inode_flag(inode, FI_AUTO_RECOVER);
1097
Jaegeuk Kim7c457292016-10-14 11:51:23 -07001098 f2fs_inode_dirtied(inode, false);
Jaegeuk Kimb3783872013-06-10 09:17:01 +09001099}
1100
Al Virod01718a2019-04-15 19:29:14 -04001101static void f2fs_free_inode(struct inode *inode)
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001102{
Eric Biggers2c58d542019-04-10 13:21:15 -07001103 fscrypt_free_inode(inode);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001104 kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode));
1105}
1106
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07001107static void destroy_percpu_info(struct f2fs_sb_info *sbi)
1108{
Jaegeuk Kim41382ec2016-05-16 11:06:50 -07001109 percpu_counter_destroy(&sbi->alloc_valid_block_count);
Jaegeuk Kim513c5f32016-05-16 11:42:32 -07001110 percpu_counter_destroy(&sbi->total_valid_inode_count);
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07001111}
1112
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07001113static void destroy_device_list(struct f2fs_sb_info *sbi)
1114{
1115 int i;
1116
1117 for (i = 0; i < sbi->s_ndevs; i++) {
1118 blkdev_put(FDEV(i).bdev, FMODE_EXCL);
1119#ifdef CONFIG_BLK_DEV_ZONED
Damien Le Moal95175da2019-03-16 09:13:07 +09001120 kvfree(FDEV(i).blkz_seq);
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07001121#endif
1122 }
Jaegeuk Kim52225952018-12-13 18:38:33 -08001123 kvfree(sbi->devs);
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07001124}
1125
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001126static void f2fs_put_super(struct super_block *sb)
1127{
1128 struct f2fs_sb_info *sbi = F2FS_SB(sb);
Chao Yua3981012017-06-14 17:39:46 +08001129 int i;
Chao Yucf5c7592017-10-04 09:08:37 +08001130 bool dropped;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001131
Chao Yu0abd6752017-07-09 00:13:07 +08001132 f2fs_quota_off_umount(sb);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001133
Jaegeuk Kim2658e502015-06-19 12:01:21 -07001134 /* prevent remaining shrinker jobs */
1135 mutex_lock(&sbi->umount_mutex);
1136
Jaegeuk Kim85dc2f22015-01-14 17:41:41 -08001137 /*
1138 * We don't need to do checkpoint when superblock is clean.
1139 * But, the previous checkpoint was not done by umount, it needs to do
1140 * clean checkpoint again.
1141 */
Daniel Rosenberg43549942018-08-20 19:21:43 -07001142 if ((is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||
1143 !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG))) {
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -07001144 struct cp_control cpc = {
1145 .reason = CP_UMOUNT,
1146 };
Chao Yu4d57b862018-05-30 00:20:41 +08001147 f2fs_write_checkpoint(sbi, &cpc);
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -07001148 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001149
Jaegeuk Kim4e6a8d92016-12-29 14:07:53 -08001150 /* be sure to wait for any on-going discard commands */
Jaegeuk Kim03f2c022019-01-14 10:42:11 -08001151 dropped = f2fs_issue_discard_timeout(sbi);
Jaegeuk Kim4e6a8d92016-12-29 14:07:53 -08001152
Chao Yu7d20c8a2018-09-04 03:52:17 +08001153 if ((f2fs_hw_support_discard(sbi) || f2fs_hw_should_discard(sbi)) &&
1154 !sbi->discard_blks && !dropped) {
Chao Yu1f43e2a2017-04-28 13:56:08 +08001155 struct cp_control cpc = {
1156 .reason = CP_UMOUNT | CP_TRIMMED,
1157 };
Chao Yu4d57b862018-05-30 00:20:41 +08001158 f2fs_write_checkpoint(sbi, &cpc);
Chao Yu1f43e2a2017-04-28 13:56:08 +08001159 }
1160
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001161 /*
1162 * normally superblock is clean, so we need to release this.
1163 * In addition, EIO will skip do checkpoint, we need this as well.
1164 */
Chao Yu4d57b862018-05-30 00:20:41 +08001165 f2fs_release_ino_entry(sbi, true);
Jaegeuk Kim6f12ac22014-08-19 09:48:22 -07001166
Jaegeuk Kim2658e502015-06-19 12:01:21 -07001167 f2fs_leave_shrinker(sbi);
1168 mutex_unlock(&sbi->umount_mutex);
1169
Jaegeuk Kim17c19122016-01-29 08:57:59 -08001170 /* our cp_error case, we can wait for any writeback page */
Jaegeuk Kimb9109b02017-05-10 11:28:38 -07001171 f2fs_flush_merged_writes(sbi);
Jaegeuk Kim17c19122016-01-29 08:57:59 -08001172
Sahitya Tummalabf22c3c2020-02-18 09:19:07 +05301173 f2fs_wait_on_all_pages(sbi, F2FS_WB_CP_DATA);
Chao Yu50fa53e2018-08-02 23:03:19 +08001174
1175 f2fs_bug_on(sbi, sbi->fsync_node_num);
1176
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001177 iput(sbi->node_inode);
Jaegeuk Kim7c77bf72019-01-01 00:11:30 -08001178 sbi->node_inode = NULL;
1179
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001180 iput(sbi->meta_inode);
Jaegeuk Kim7c77bf72019-01-01 00:11:30 -08001181 sbi->meta_inode = NULL;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001182
Sahitya Tummala60aa4d52018-12-26 11:20:29 +05301183 /*
1184 * iput() can update stat information, if f2fs_write_checkpoint()
1185 * above failed with error.
1186 */
1187 f2fs_destroy_stats(sbi);
1188
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001189 /* destroy f2fs internal modules */
Chao Yu4d57b862018-05-30 00:20:41 +08001190 f2fs_destroy_node_manager(sbi);
1191 f2fs_destroy_segment_manager(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001192
Chao Yu4c8ff702019-11-01 18:07:14 +08001193 f2fs_destroy_post_read_wq(sbi);
1194
Jaegeuk Kim52225952018-12-13 18:38:33 -08001195 kvfree(sbi->ckpt);
Chao Yua3981012017-06-14 17:39:46 +08001196
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -07001197 f2fs_unregister_sysfs(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001198
1199 sb->s_fs_info = NULL;
Keith Mok43b65732016-03-02 12:04:24 -08001200 if (sbi->s_chksum_driver)
1201 crypto_free_shash(sbi->s_chksum_driver);
Jaegeuk Kim52225952018-12-13 18:38:33 -08001202 kvfree(sbi->raw_super);
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07001203
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07001204 destroy_device_list(sbi);
Chao Yua9991502020-02-25 18:17:10 +08001205 f2fs_destroy_xattr_caches(sbi);
Chao Yub6895e82017-02-27 18:43:12 +08001206 mempool_destroy(sbi->write_io_dummy);
Chao Yu4b2414d2017-08-08 10:54:31 +08001207#ifdef CONFIG_QUOTA
1208 for (i = 0; i < MAXQUOTAS; i++)
Jaegeuk Kim52225952018-12-13 18:38:33 -08001209 kvfree(F2FS_OPTION(sbi).s_qf_names[i]);
Chao Yu4b2414d2017-08-08 10:54:31 +08001210#endif
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07001211 destroy_percpu_info(sbi);
Jaegeuk Kima912b542017-05-10 11:18:25 -07001212 for (i = 0; i < NR_PAGE_TYPE; i++)
Jaegeuk Kim52225952018-12-13 18:38:33 -08001213 kvfree(sbi->write_io[i]);
Daniel Rosenberg5aba5432019-07-23 16:05:28 -07001214#ifdef CONFIG_UNICODE
1215 utf8_unload(sbi->s_encoding);
1216#endif
Jaegeuk Kim52225952018-12-13 18:38:33 -08001217 kvfree(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001218}
1219
1220int f2fs_sync_fs(struct super_block *sb, int sync)
1221{
1222 struct f2fs_sb_info *sbi = F2FS_SB(sb);
Chao Yuc34f42e2015-12-23 17:50:30 +08001223 int err = 0;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001224
Jaegeuk Kim1f227a32017-10-23 23:48:49 +02001225 if (unlikely(f2fs_cp_error(sbi)))
1226 return 0;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001227 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
1228 return 0;
Jaegeuk Kim1f227a32017-10-23 23:48:49 +02001229
Namjae Jeona2a4a7e2013-04-20 01:28:40 +09001230 trace_f2fs_sync_fs(sb, sync);
1231
Chao Yu4b2414d2017-08-08 10:54:31 +08001232 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
1233 return -EAGAIN;
1234
Jaegeuk Kimb7473752013-04-01 08:32:21 +09001235 if (sync) {
Jaegeuk Kimd5053a342014-10-30 22:47:03 -07001236 struct cp_control cpc;
1237
Jaegeuk Kim119ee912015-01-29 11:45:33 -08001238 cpc.reason = __get_cp_reason(sbi);
1239
Chao Yufb24fea2020-01-14 19:36:50 +08001240 down_write(&sbi->gc_lock);
Chao Yu4d57b862018-05-30 00:20:41 +08001241 err = f2fs_write_checkpoint(sbi, &cpc);
Chao Yufb24fea2020-01-14 19:36:50 +08001242 up_write(&sbi->gc_lock);
Jaegeuk Kimb7473752013-04-01 08:32:21 +09001243 }
Jaegeuk Kim05ca3632015-04-23 14:38:15 -07001244 f2fs_trace_ios(NULL, 1);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001245
Chao Yuc34f42e2015-12-23 17:50:30 +08001246 return err;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001247}
1248
Changman Leed6212a52013-01-29 18:30:07 +09001249static int f2fs_freeze(struct super_block *sb)
1250{
Jaegeuk Kim77888c12013-05-20 20:28:47 +09001251 if (f2fs_readonly(sb))
Changman Leed6212a52013-01-29 18:30:07 +09001252 return 0;
1253
Jaegeuk Kimb4b9d342016-11-04 14:59:15 -07001254 /* IO error happened before */
1255 if (unlikely(f2fs_cp_error(F2FS_SB(sb))))
1256 return -EIO;
1257
1258 /* must be clean, since sync_filesystem() was already called */
1259 if (is_sbi_flag_set(F2FS_SB(sb), SBI_IS_DIRTY))
1260 return -EINVAL;
1261 return 0;
Changman Leed6212a52013-01-29 18:30:07 +09001262}
1263
1264static int f2fs_unfreeze(struct super_block *sb)
1265{
1266 return 0;
1267}
1268
Chao Yuddc34e32017-07-29 00:32:53 +08001269#ifdef CONFIG_QUOTA
1270static int f2fs_statfs_project(struct super_block *sb,
1271 kprojid_t projid, struct kstatfs *buf)
1272{
1273 struct kqid qid;
1274 struct dquot *dquot;
1275 u64 limit;
1276 u64 curblock;
1277
1278 qid = make_kqid_projid(projid);
1279 dquot = dqget(sb, qid);
1280 if (IS_ERR(dquot))
1281 return PTR_ERR(dquot);
Sheng Yong955ac6e2018-07-24 20:17:53 +08001282 spin_lock(&dquot->dq_dqb_lock);
Chao Yuddc34e32017-07-29 00:32:53 +08001283
Chengguang Xubf2cbd32020-01-04 22:20:04 +08001284 limit = min_not_zero(dquot->dq_dqb.dqb_bsoftlimit,
1285 dquot->dq_dqb.dqb_bhardlimit);
Chengguang Xuacdf2172020-01-04 22:20:03 +08001286 if (limit)
1287 limit >>= sb->s_blocksize_bits;
Chengguang Xu909110c2019-11-25 11:20:36 +08001288
Chao Yuddc34e32017-07-29 00:32:53 +08001289 if (limit && buf->f_blocks > limit) {
1290 curblock = dquot->dq_dqb.dqb_curspace >> sb->s_blocksize_bits;
1291 buf->f_blocks = limit;
1292 buf->f_bfree = buf->f_bavail =
1293 (buf->f_blocks > curblock) ?
1294 (buf->f_blocks - curblock) : 0;
1295 }
1296
Chengguang Xubf2cbd32020-01-04 22:20:04 +08001297 limit = min_not_zero(dquot->dq_dqb.dqb_isoftlimit,
1298 dquot->dq_dqb.dqb_ihardlimit);
Chengguang Xu909110c2019-11-25 11:20:36 +08001299
Chao Yuddc34e32017-07-29 00:32:53 +08001300 if (limit && buf->f_files > limit) {
1301 buf->f_files = limit;
1302 buf->f_ffree =
1303 (buf->f_files > dquot->dq_dqb.dqb_curinodes) ?
1304 (buf->f_files - dquot->dq_dqb.dqb_curinodes) : 0;
1305 }
1306
Sheng Yong955ac6e2018-07-24 20:17:53 +08001307 spin_unlock(&dquot->dq_dqb_lock);
Chao Yuddc34e32017-07-29 00:32:53 +08001308 dqput(dquot);
1309 return 0;
1310}
1311#endif
1312
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001313static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)
1314{
1315 struct super_block *sb = dentry->d_sb;
1316 struct f2fs_sb_info *sbi = F2FS_SB(sb);
1317 u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
Jaegeuk Kimf66c0272018-01-03 10:55:07 -08001318 block_t total_count, user_block_count, start_count;
Jaegeuk Kim0cc091d2017-06-21 20:55:55 -07001319 u64 avail_node_count;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001320
1321 total_count = le64_to_cpu(sbi->raw_super->block_count);
1322 user_block_count = sbi->user_block_count;
1323 start_count = le32_to_cpu(sbi->raw_super->segment0_blkaddr);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001324 buf->f_type = F2FS_SUPER_MAGIC;
1325 buf->f_bsize = sbi->blocksize;
1326
1327 buf->f_blocks = total_count - start_count;
Jaegeuk Kimf66c0272018-01-03 10:55:07 -08001328 buf->f_bfree = user_block_count - valid_user_blocks(sbi) -
Yunlong Song80d42142017-10-27 20:45:05 +08001329 sbi->current_reserved_blocks;
Chao Yuc9c8ed52019-05-05 11:40:46 +08001330
1331 spin_lock(&sbi->stat_lock);
Daniel Rosenberg43549942018-08-20 19:21:43 -07001332 if (unlikely(buf->f_bfree <= sbi->unusable_block_count))
1333 buf->f_bfree = 0;
1334 else
1335 buf->f_bfree -= sbi->unusable_block_count;
Chao Yuc9c8ed52019-05-05 11:40:46 +08001336 spin_unlock(&sbi->stat_lock);
Daniel Rosenberg43549942018-08-20 19:21:43 -07001337
Chao Yu63189b72018-03-08 14:22:56 +08001338 if (buf->f_bfree > F2FS_OPTION(sbi).root_reserved_blocks)
1339 buf->f_bavail = buf->f_bfree -
1340 F2FS_OPTION(sbi).root_reserved_blocks;
Jaegeuk Kim7e65be42017-12-27 15:05:52 -08001341 else
1342 buf->f_bavail = 0;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001343
Chao Yu27cae0b2019-08-05 18:27:25 +08001344 avail_node_count = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;
Jaegeuk Kim0cc091d2017-06-21 20:55:55 -07001345
1346 if (avail_node_count > user_block_count) {
1347 buf->f_files = user_block_count;
1348 buf->f_ffree = buf->f_bavail;
1349 } else {
1350 buf->f_files = avail_node_count;
1351 buf->f_ffree = min(avail_node_count - valid_node_count(sbi),
1352 buf->f_bavail);
1353 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001354
Jaegeuk Kim5a20d332013-03-03 13:58:05 +09001355 buf->f_namelen = F2FS_NAME_LEN;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001356 buf->f_fsid.val[0] = (u32)id;
1357 buf->f_fsid.val[1] = (u32)(id >> 32);
1358
Chao Yuddc34e32017-07-29 00:32:53 +08001359#ifdef CONFIG_QUOTA
1360 if (is_inode_flag_set(dentry->d_inode, FI_PROJ_INHERIT) &&
1361 sb_has_quota_limits_enabled(sb, PRJQUOTA)) {
1362 f2fs_statfs_project(sb, F2FS_I(dentry->d_inode)->i_projid, buf);
1363 }
1364#endif
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001365 return 0;
1366}
1367
Chao Yu4b2414d2017-08-08 10:54:31 +08001368static inline void f2fs_show_quota_options(struct seq_file *seq,
1369 struct super_block *sb)
1370{
1371#ifdef CONFIG_QUOTA
1372 struct f2fs_sb_info *sbi = F2FS_SB(sb);
1373
Chao Yu63189b72018-03-08 14:22:56 +08001374 if (F2FS_OPTION(sbi).s_jquota_fmt) {
Chao Yu4b2414d2017-08-08 10:54:31 +08001375 char *fmtname = "";
1376
Chao Yu63189b72018-03-08 14:22:56 +08001377 switch (F2FS_OPTION(sbi).s_jquota_fmt) {
Chao Yu4b2414d2017-08-08 10:54:31 +08001378 case QFMT_VFS_OLD:
1379 fmtname = "vfsold";
1380 break;
1381 case QFMT_VFS_V0:
1382 fmtname = "vfsv0";
1383 break;
1384 case QFMT_VFS_V1:
1385 fmtname = "vfsv1";
1386 break;
1387 }
1388 seq_printf(seq, ",jqfmt=%s", fmtname);
1389 }
1390
Chao Yu63189b72018-03-08 14:22:56 +08001391 if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA])
1392 seq_show_option(seq, "usrjquota",
1393 F2FS_OPTION(sbi).s_qf_names[USRQUOTA]);
Chao Yu4b2414d2017-08-08 10:54:31 +08001394
Chao Yu63189b72018-03-08 14:22:56 +08001395 if (F2FS_OPTION(sbi).s_qf_names[GRPQUOTA])
1396 seq_show_option(seq, "grpjquota",
1397 F2FS_OPTION(sbi).s_qf_names[GRPQUOTA]);
Chao Yu4b2414d2017-08-08 10:54:31 +08001398
Chao Yu63189b72018-03-08 14:22:56 +08001399 if (F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])
1400 seq_show_option(seq, "prjjquota",
1401 F2FS_OPTION(sbi).s_qf_names[PRJQUOTA]);
Chao Yu4b2414d2017-08-08 10:54:31 +08001402#endif
1403}
1404
Chao Yu4c8ff702019-11-01 18:07:14 +08001405static inline void f2fs_show_compress_options(struct seq_file *seq,
1406 struct super_block *sb)
1407{
1408 struct f2fs_sb_info *sbi = F2FS_SB(sb);
1409 char *algtype = "";
1410 int i;
1411
1412 if (!f2fs_sb_has_compression(sbi))
1413 return;
1414
1415 switch (F2FS_OPTION(sbi).compress_algorithm) {
1416 case COMPRESS_LZO:
1417 algtype = "lzo";
1418 break;
1419 case COMPRESS_LZ4:
1420 algtype = "lz4";
1421 break;
1422 }
1423 seq_printf(seq, ",compress_algorithm=%s", algtype);
1424
1425 seq_printf(seq, ",compress_log_size=%u",
1426 F2FS_OPTION(sbi).compress_log_size);
1427
1428 for (i = 0; i < F2FS_OPTION(sbi).compress_ext_cnt; i++) {
1429 seq_printf(seq, ",compress_extension=%s",
1430 F2FS_OPTION(sbi).extensions[i]);
1431 }
1432}
1433
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001434static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
1435{
1436 struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb);
1437
Chao Yubbbc34f2020-02-14 17:44:13 +08001438 if (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_SYNC)
1439 seq_printf(seq, ",background_gc=%s", "sync");
1440 else if (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_ON)
1441 seq_printf(seq, ",background_gc=%s", "on");
1442 else if (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_OFF)
Namjae Jeon696c0182013-06-16 09:48:48 +09001443 seq_printf(seq, ",background_gc=%s", "off");
Chao Yubbbc34f2020-02-14 17:44:13 +08001444
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001445 if (test_opt(sbi, DISABLE_ROLL_FORWARD))
1446 seq_puts(seq, ",disable_roll_forward");
Chao Yua9117ec2020-02-14 17:45:11 +08001447 if (test_opt(sbi, NORECOVERY))
1448 seq_puts(seq, ",norecovery");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001449 if (test_opt(sbi, DISCARD))
1450 seq_puts(seq, ",discard");
Sahitya Tummala81621f92019-05-24 14:38:39 +05301451 else
1452 seq_puts(seq, ",nodiscard");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001453 if (test_opt(sbi, NOHEAP))
Jaegeuk Kim7a20b8a2017-03-24 20:41:45 -04001454 seq_puts(seq, ",no_heap");
1455 else
1456 seq_puts(seq, ",heap");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001457#ifdef CONFIG_F2FS_FS_XATTR
1458 if (test_opt(sbi, XATTR_USER))
1459 seq_puts(seq, ",user_xattr");
1460 else
1461 seq_puts(seq, ",nouser_xattr");
Jaegeuk Kim444c5802013-08-08 15:16:22 +09001462 if (test_opt(sbi, INLINE_XATTR))
1463 seq_puts(seq, ",inline_xattr");
Chao Yu23cf7212017-02-15 10:34:45 +08001464 else
1465 seq_puts(seq, ",noinline_xattr");
Chao Yu6afc6622017-09-06 21:59:50 +08001466 if (test_opt(sbi, INLINE_XATTR_SIZE))
1467 seq_printf(seq, ",inline_xattr_size=%u",
Chao Yu63189b72018-03-08 14:22:56 +08001468 F2FS_OPTION(sbi).inline_xattr_size);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001469#endif
1470#ifdef CONFIG_F2FS_FS_POSIX_ACL
1471 if (test_opt(sbi, POSIX_ACL))
1472 seq_puts(seq, ",acl");
1473 else
1474 seq_puts(seq, ",noacl");
1475#endif
1476 if (test_opt(sbi, DISABLE_EXT_IDENTIFY))
Alejandro Martinez Ruizaa435072013-01-25 19:08:59 +01001477 seq_puts(seq, ",disable_ext_identify");
Huajun Li8274de72013-11-10 23:13:17 +08001478 if (test_opt(sbi, INLINE_DATA))
1479 seq_puts(seq, ",inline_data");
Wanpeng Li75342792015-03-24 10:20:27 +08001480 else
1481 seq_puts(seq, ",noinline_data");
Chao Yu5efd3c62014-09-24 18:16:13 +08001482 if (test_opt(sbi, INLINE_DENTRY))
1483 seq_puts(seq, ",inline_dentry");
Chao Yu97c17942016-05-09 19:56:34 +08001484 else
1485 seq_puts(seq, ",noinline_dentry");
Gu Zhengb270ad62014-04-11 17:49:55 +08001486 if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE))
Jaegeuk Kim6b4afdd2014-04-02 15:34:36 +09001487 seq_puts(seq, ",flush_merge");
Jaegeuk Kim0f7b2ab2014-07-23 09:57:31 -07001488 if (test_opt(sbi, NOBARRIER))
1489 seq_puts(seq, ",nobarrier");
Jaegeuk Kimd5053a342014-10-30 22:47:03 -07001490 if (test_opt(sbi, FASTBOOT))
1491 seq_puts(seq, ",fastboot");
Chao Yu89672152015-02-05 17:55:51 +08001492 if (test_opt(sbi, EXTENT_CACHE))
1493 seq_puts(seq, ",extent_cache");
Jaegeuk Kim7daaea22015-06-25 17:43:04 -07001494 else
1495 seq_puts(seq, ",noextent_cache");
Chao Yu343f40f2015-12-16 13:12:16 +08001496 if (test_opt(sbi, DATA_FLUSH))
1497 seq_puts(seq, ",data_flush");
Jaegeuk Kim36abef42016-06-03 19:29:38 -07001498
1499 seq_puts(seq, ",mode=");
Chao Yub0332a02020-02-14 17:44:12 +08001500 if (F2FS_OPTION(sbi).fs_mode == FS_MODE_ADAPTIVE)
Jaegeuk Kim36abef42016-06-03 19:29:38 -07001501 seq_puts(seq, "adaptive");
Chao Yub0332a02020-02-14 17:44:12 +08001502 else if (F2FS_OPTION(sbi).fs_mode == FS_MODE_LFS)
Jaegeuk Kim36abef42016-06-03 19:29:38 -07001503 seq_puts(seq, "lfs");
Chao Yu63189b72018-03-08 14:22:56 +08001504 seq_printf(seq, ",active_logs=%u", F2FS_OPTION(sbi).active_logs);
Jaegeuk Kim7e65be42017-12-27 15:05:52 -08001505 if (test_opt(sbi, RESERVE_ROOT))
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -08001506 seq_printf(seq, ",reserve_root=%u,resuid=%u,resgid=%u",
Chao Yu63189b72018-03-08 14:22:56 +08001507 F2FS_OPTION(sbi).root_reserved_blocks,
1508 from_kuid_munged(&init_user_ns,
1509 F2FS_OPTION(sbi).s_resuid),
1510 from_kgid_munged(&init_user_ns,
1511 F2FS_OPTION(sbi).s_resgid));
Jaegeuk Kimec915382016-12-21 17:09:19 -08001512 if (F2FS_IO_SIZE_BITS(sbi))
Chengguang Xuc6b18672018-09-22 22:43:09 +08001513 seq_printf(seq, ",io_bits=%u",
1514 F2FS_OPTION(sbi).write_io_size_bits);
Kaixu Xia0cc0dec2017-01-27 09:35:37 +08001515#ifdef CONFIG_F2FS_FAULT_INJECTION
Chao Yud4945002018-08-08 17:36:41 +08001516 if (test_opt(sbi, FAULT_INJECTION)) {
Chao Yu44529f82017-06-12 09:44:24 +08001517 seq_printf(seq, ",fault_injection=%u",
Chao Yu63189b72018-03-08 14:22:56 +08001518 F2FS_OPTION(sbi).fault_info.inject_rate);
Chao Yud4945002018-08-08 17:36:41 +08001519 seq_printf(seq, ",fault_type=%u",
1520 F2FS_OPTION(sbi).fault_info.inject_type);
1521 }
Kaixu Xia0cc0dec2017-01-27 09:35:37 +08001522#endif
Chao Yu0abd6752017-07-09 00:13:07 +08001523#ifdef CONFIG_QUOTA
Chao Yu4b2414d2017-08-08 10:54:31 +08001524 if (test_opt(sbi, QUOTA))
1525 seq_puts(seq, ",quota");
Chao Yu0abd6752017-07-09 00:13:07 +08001526 if (test_opt(sbi, USRQUOTA))
1527 seq_puts(seq, ",usrquota");
1528 if (test_opt(sbi, GRPQUOTA))
1529 seq_puts(seq, ",grpquota");
Chao Yu5c571322017-07-26 00:01:41 +08001530 if (test_opt(sbi, PRJQUOTA))
1531 seq_puts(seq, ",prjquota");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001532#endif
Chao Yu4b2414d2017-08-08 10:54:31 +08001533 f2fs_show_quota_options(seq, sbi->sb);
Chao Yu63189b72018-03-08 14:22:56 +08001534 if (F2FS_OPTION(sbi).whint_mode == WHINT_MODE_USER)
Hyunchul Lee0cdd3192018-01-31 11:36:57 +09001535 seq_printf(seq, ",whint_mode=%s", "user-based");
Chao Yu63189b72018-03-08 14:22:56 +08001536 else if (F2FS_OPTION(sbi).whint_mode == WHINT_MODE_FS)
Hyunchul Leef2e703f2018-01-31 11:36:58 +09001537 seq_printf(seq, ",whint_mode=%s", "fs-based");
Chandan Rajendra643fa962018-12-12 15:20:12 +05301538#ifdef CONFIG_FS_ENCRYPTION
Sheng Yongff62af22018-03-15 18:51:42 +08001539 if (F2FS_OPTION(sbi).test_dummy_encryption)
1540 seq_puts(seq, ",test_dummy_encryption");
1541#endif
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001542
Chao Yu63189b72018-03-08 14:22:56 +08001543 if (F2FS_OPTION(sbi).alloc_mode == ALLOC_MODE_DEFAULT)
Jaegeuk Kim07939622018-02-18 08:50:49 -08001544 seq_printf(seq, ",alloc_mode=%s", "default");
Chao Yu63189b72018-03-08 14:22:56 +08001545 else if (F2FS_OPTION(sbi).alloc_mode == ALLOC_MODE_REUSE)
Jaegeuk Kim07939622018-02-18 08:50:49 -08001546 seq_printf(seq, ",alloc_mode=%s", "reuse");
Junling Zheng93cf93f2018-03-07 12:07:49 +08001547
Daniel Rosenberg43549942018-08-20 19:21:43 -07001548 if (test_opt(sbi, DISABLE_CHECKPOINT))
Daniel Rosenberg4d3aed72019-05-29 17:49:06 -07001549 seq_printf(seq, ",checkpoint=disable:%u",
1550 F2FS_OPTION(sbi).unusable_cap);
Chao Yu63189b72018-03-08 14:22:56 +08001551 if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_POSIX)
Junling Zheng93cf93f2018-03-07 12:07:49 +08001552 seq_printf(seq, ",fsync_mode=%s", "posix");
Chao Yu63189b72018-03-08 14:22:56 +08001553 else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT)
Junling Zheng93cf93f2018-03-07 12:07:49 +08001554 seq_printf(seq, ",fsync_mode=%s", "strict");
Sahitya Tummaladc132802018-07-02 11:37:40 +05301555 else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_NOBARRIER)
1556 seq_printf(seq, ",fsync_mode=%s", "nobarrier");
Chao Yu4c8ff702019-11-01 18:07:14 +08001557
1558 f2fs_show_compress_options(seq, sbi->sb);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001559 return 0;
1560}
1561
Yunlei He498c5e92015-05-07 18:11:37 +08001562static void default_options(struct f2fs_sb_info *sbi)
1563{
1564 /* init some FS parameters */
Chao Yu63189b72018-03-08 14:22:56 +08001565 F2FS_OPTION(sbi).active_logs = NR_CURSEG_TYPE;
1566 F2FS_OPTION(sbi).inline_xattr_size = DEFAULT_INLINE_XATTR_ADDRS;
1567 F2FS_OPTION(sbi).whint_mode = WHINT_MODE_OFF;
1568 F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;
1569 F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;
Sheng Yongff62af22018-03-15 18:51:42 +08001570 F2FS_OPTION(sbi).test_dummy_encryption = false;
Chao Yu0aa7e0f2018-06-06 23:55:02 +08001571 F2FS_OPTION(sbi).s_resuid = make_kuid(&init_user_ns, F2FS_DEF_RESUID);
1572 F2FS_OPTION(sbi).s_resgid = make_kgid(&init_user_ns, F2FS_DEF_RESGID);
Chao Yu91faa532020-03-10 20:50:05 +08001573 F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZ4;
Chao Yu4c8ff702019-11-01 18:07:14 +08001574 F2FS_OPTION(sbi).compress_log_size = MIN_COMPRESS_LOG_SIZE;
1575 F2FS_OPTION(sbi).compress_ext_cnt = 0;
Chao Yubbbc34f2020-02-14 17:44:13 +08001576 F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ON;
Yunlei He498c5e92015-05-07 18:11:37 +08001577
Chao Yu39133a52017-02-08 17:39:44 +08001578 set_opt(sbi, INLINE_XATTR);
Yunlei He498c5e92015-05-07 18:11:37 +08001579 set_opt(sbi, INLINE_DATA);
Chao Yu97c17942016-05-09 19:56:34 +08001580 set_opt(sbi, INLINE_DENTRY);
Jaegeuk Kim3e72f722015-06-19 17:53:26 -07001581 set_opt(sbi, EXTENT_CACHE);
Jaegeuk Kim7a20b8a2017-03-24 20:41:45 -04001582 set_opt(sbi, NOHEAP);
Daniel Rosenberg43549942018-08-20 19:21:43 -07001583 clear_opt(sbi, DISABLE_CHECKPOINT);
Daniel Rosenberg4d3aed72019-05-29 17:49:06 -07001584 F2FS_OPTION(sbi).unusable_cap = 0;
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001585 sbi->sb->s_flags |= SB_LAZYTIME;
Jaegeuk Kim69e9e422016-05-20 22:39:20 -07001586 set_opt(sbi, FLUSH_MERGE);
Chao Yu7d20c8a2018-09-04 03:52:17 +08001587 set_opt(sbi, DISCARD);
Chao Yu7beb01f2018-10-24 18:34:26 +08001588 if (f2fs_sb_has_blkzoned(sbi))
Chao Yub0332a02020-02-14 17:44:12 +08001589 F2FS_OPTION(sbi).fs_mode = FS_MODE_LFS;
Chao Yua39e53652018-07-05 14:24:11 +08001590 else
Chao Yub0332a02020-02-14 17:44:12 +08001591 F2FS_OPTION(sbi).fs_mode = FS_MODE_ADAPTIVE;
Yunlei He498c5e92015-05-07 18:11:37 +08001592
1593#ifdef CONFIG_F2FS_FS_XATTR
1594 set_opt(sbi, XATTR_USER);
1595#endif
1596#ifdef CONFIG_F2FS_FS_POSIX_ACL
1597 set_opt(sbi, POSIX_ACL);
1598#endif
Chao Yu36dbd322016-09-26 19:45:05 +08001599
Chao Yud4945002018-08-08 17:36:41 +08001600 f2fs_build_fault_attr(sbi, 0, 0);
Yunlei He498c5e92015-05-07 18:11:37 +08001601}
1602
Jaegeuk Kimea676732017-10-06 09:14:28 -07001603#ifdef CONFIG_QUOTA
1604static int f2fs_enable_quotas(struct super_block *sb);
1605#endif
Daniel Rosenberg43549942018-08-20 19:21:43 -07001606
1607static int f2fs_disable_checkpoint(struct f2fs_sb_info *sbi)
1608{
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001609 unsigned int s_flags = sbi->sb->s_flags;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001610 struct cp_control cpc;
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001611 int err = 0;
1612 int ret;
Daniel Rosenberg4d3aed72019-05-29 17:49:06 -07001613 block_t unusable;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001614
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001615 if (s_flags & SB_RDONLY) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08001616 f2fs_err(sbi, "checkpoint=disable on readonly fs");
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001617 return -EINVAL;
1618 }
Daniel Rosenberg43549942018-08-20 19:21:43 -07001619 sbi->sb->s_flags |= SB_ACTIVE;
1620
Daniel Rosenberg43549942018-08-20 19:21:43 -07001621 f2fs_update_time(sbi, DISABLE_TIME);
1622
1623 while (!f2fs_time_over(sbi, DISABLE_TIME)) {
Chao Yufb24fea2020-01-14 19:36:50 +08001624 down_write(&sbi->gc_lock);
Daniel Rosenberg43549942018-08-20 19:21:43 -07001625 err = f2fs_gc(sbi, true, false, NULL_SEGNO);
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001626 if (err == -ENODATA) {
1627 err = 0;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001628 break;
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001629 }
Jaegeuk Kim8f31b462018-12-17 17:08:26 -08001630 if (err && err != -EAGAIN)
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001631 break;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001632 }
Daniel Rosenberg43549942018-08-20 19:21:43 -07001633
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001634 ret = sync_filesystem(sbi->sb);
1635 if (ret || err) {
1636 err = ret ? ret: err;
1637 goto restore_flag;
1638 }
Daniel Rosenberg43549942018-08-20 19:21:43 -07001639
Daniel Rosenberg4d3aed72019-05-29 17:49:06 -07001640 unusable = f2fs_get_unusable_blocks(sbi);
1641 if (f2fs_disable_cp_again(sbi, unusable)) {
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001642 err = -EAGAIN;
1643 goto restore_flag;
1644 }
Daniel Rosenberg43549942018-08-20 19:21:43 -07001645
Chao Yufb24fea2020-01-14 19:36:50 +08001646 down_write(&sbi->gc_lock);
Daniel Rosenberg43549942018-08-20 19:21:43 -07001647 cpc.reason = CP_PAUSE;
1648 set_sbi_flag(sbi, SBI_CP_DISABLED);
Chao Yu896285a2019-04-26 17:57:54 +08001649 err = f2fs_write_checkpoint(sbi, &cpc);
1650 if (err)
1651 goto out_unlock;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001652
Chao Yuc9c8ed52019-05-05 11:40:46 +08001653 spin_lock(&sbi->stat_lock);
Daniel Rosenberg4d3aed72019-05-29 17:49:06 -07001654 sbi->unusable_block_count = unusable;
Chao Yuc9c8ed52019-05-05 11:40:46 +08001655 spin_unlock(&sbi->stat_lock);
1656
Chao Yu896285a2019-04-26 17:57:54 +08001657out_unlock:
Chao Yufb24fea2020-01-14 19:36:50 +08001658 up_write(&sbi->gc_lock);
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001659restore_flag:
Chao Yu7a88ddb2020-02-27 19:30:05 +08001660 sbi->sb->s_flags = s_flags; /* Restore SB_RDONLY status */
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001661 return err;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001662}
1663
1664static void f2fs_enable_checkpoint(struct f2fs_sb_info *sbi)
1665{
Chao Yufb24fea2020-01-14 19:36:50 +08001666 down_write(&sbi->gc_lock);
Daniel Rosenberg43549942018-08-20 19:21:43 -07001667 f2fs_dirty_to_prefree(sbi);
1668
1669 clear_sbi_flag(sbi, SBI_CP_DISABLED);
1670 set_sbi_flag(sbi, SBI_IS_DIRTY);
Chao Yufb24fea2020-01-14 19:36:50 +08001671 up_write(&sbi->gc_lock);
Daniel Rosenberg43549942018-08-20 19:21:43 -07001672
1673 f2fs_sync_fs(sbi->sb, 1);
1674}
1675
Namjae Jeon696c0182013-06-16 09:48:48 +09001676static int f2fs_remount(struct super_block *sb, int *flags, char *data)
1677{
1678 struct f2fs_sb_info *sbi = F2FS_SB(sb);
1679 struct f2fs_mount_info org_mount_opt;
Chao Yu0abd6752017-07-09 00:13:07 +08001680 unsigned long old_sb_flags;
Chao Yu63189b72018-03-08 14:22:56 +08001681 int err;
Gu Zheng876dc592014-04-11 17:50:00 +08001682 bool need_restart_gc = false;
1683 bool need_stop_gc = false;
Chao Yu9cd81ce2015-09-18 16:55:26 +08001684 bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE);
Daniel Rosenberg43549942018-08-20 19:21:43 -07001685 bool disable_checkpoint = test_opt(sbi, DISABLE_CHECKPOINT);
Chao Yu1f78adf2019-07-12 16:57:00 +08001686 bool no_io_align = !F2FS_IO_ALIGNED(sbi);
Daniel Rosenberg43549942018-08-20 19:21:43 -07001687 bool checkpoint_changed;
Chao Yu4b2414d2017-08-08 10:54:31 +08001688#ifdef CONFIG_QUOTA
Chao Yu4b2414d2017-08-08 10:54:31 +08001689 int i, j;
1690#endif
Namjae Jeon696c0182013-06-16 09:48:48 +09001691
1692 /*
1693 * Save the old mount options in case we
1694 * need to restore them.
1695 */
1696 org_mount_opt = sbi->mount_opt;
Chao Yu0abd6752017-07-09 00:13:07 +08001697 old_sb_flags = sb->s_flags;
Namjae Jeon696c0182013-06-16 09:48:48 +09001698
Chao Yu4b2414d2017-08-08 10:54:31 +08001699#ifdef CONFIG_QUOTA
Chao Yu63189b72018-03-08 14:22:56 +08001700 org_mount_opt.s_jquota_fmt = F2FS_OPTION(sbi).s_jquota_fmt;
Chao Yu4b2414d2017-08-08 10:54:31 +08001701 for (i = 0; i < MAXQUOTAS; i++) {
Chao Yu63189b72018-03-08 14:22:56 +08001702 if (F2FS_OPTION(sbi).s_qf_names[i]) {
1703 org_mount_opt.s_qf_names[i] =
1704 kstrdup(F2FS_OPTION(sbi).s_qf_names[i],
1705 GFP_KERNEL);
1706 if (!org_mount_opt.s_qf_names[i]) {
Chao Yu4b2414d2017-08-08 10:54:31 +08001707 for (j = 0; j < i; j++)
Jaegeuk Kim52225952018-12-13 18:38:33 -08001708 kvfree(org_mount_opt.s_qf_names[j]);
Chao Yu4b2414d2017-08-08 10:54:31 +08001709 return -ENOMEM;
1710 }
1711 } else {
Chao Yu63189b72018-03-08 14:22:56 +08001712 org_mount_opt.s_qf_names[i] = NULL;
Chao Yu4b2414d2017-08-08 10:54:31 +08001713 }
1714 }
1715#endif
1716
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07001717 /* recover superblocks we couldn't write due to previous RO mount */
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001718 if (!(*flags & SB_RDONLY) && is_sbi_flag_set(sbi, SBI_NEED_SB_WRITE)) {
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07001719 err = f2fs_commit_super(sbi, false);
Joe Perchesdcbb4c12019-06-18 17:48:42 +08001720 f2fs_info(sbi, "Try to recover all the superblocks, ret: %d",
1721 err);
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07001722 if (!err)
1723 clear_sbi_flag(sbi, SBI_NEED_SB_WRITE);
1724 }
1725
Yunlei He498c5e92015-05-07 18:11:37 +08001726 default_options(sbi);
Chao Yu26666c82014-09-15 18:04:44 +08001727
Namjae Jeon696c0182013-06-16 09:48:48 +09001728 /* parse mount options */
1729 err = parse_options(sb, data);
1730 if (err)
1731 goto restore_opts;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001732 checkpoint_changed =
1733 disable_checkpoint != test_opt(sbi, DISABLE_CHECKPOINT);
Namjae Jeon696c0182013-06-16 09:48:48 +09001734
1735 /*
1736 * Previous and new state of filesystem is RO,
Gu Zheng876dc592014-04-11 17:50:00 +08001737 * so skip checking GC and FLUSH_MERGE conditions.
Namjae Jeon696c0182013-06-16 09:48:48 +09001738 */
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001739 if (f2fs_readonly(sb) && (*flags & SB_RDONLY))
Namjae Jeon696c0182013-06-16 09:48:48 +09001740 goto skip;
1741
Jaegeuk Kimea676732017-10-06 09:14:28 -07001742#ifdef CONFIG_QUOTA
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001743 if (!f2fs_readonly(sb) && (*flags & SB_RDONLY)) {
Chao Yu0abd6752017-07-09 00:13:07 +08001744 err = dquot_suspend(sb, -1);
1745 if (err < 0)
1746 goto restore_opts;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001747 } else if (f2fs_readonly(sb) && !(*flags & SB_RDONLY)) {
Chao Yu0abd6752017-07-09 00:13:07 +08001748 /* dquot_resume needs RW */
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001749 sb->s_flags &= ~SB_RDONLY;
Jaegeuk Kimea676732017-10-06 09:14:28 -07001750 if (sb_any_quota_suspended(sb)) {
1751 dquot_resume(sb, -1);
Chao Yu7beb01f2018-10-24 18:34:26 +08001752 } else if (f2fs_sb_has_quota_ino(sbi)) {
Jaegeuk Kimea676732017-10-06 09:14:28 -07001753 err = f2fs_enable_quotas(sb);
1754 if (err)
1755 goto restore_opts;
1756 }
Chao Yu0abd6752017-07-09 00:13:07 +08001757 }
Jaegeuk Kimea676732017-10-06 09:14:28 -07001758#endif
Chao Yu9cd81ce2015-09-18 16:55:26 +08001759 /* disallow enable/disable extent_cache dynamically */
1760 if (no_extent_cache == !!test_opt(sbi, EXTENT_CACHE)) {
1761 err = -EINVAL;
Joe Perchesdcbb4c12019-06-18 17:48:42 +08001762 f2fs_warn(sbi, "switch extent_cache option is not allowed");
Chao Yu9cd81ce2015-09-18 16:55:26 +08001763 goto restore_opts;
1764 }
1765
Chao Yu1f78adf2019-07-12 16:57:00 +08001766 if (no_io_align == !!F2FS_IO_ALIGNED(sbi)) {
1767 err = -EINVAL;
1768 f2fs_warn(sbi, "switch io_bits option is not allowed");
1769 goto restore_opts;
1770 }
1771
Daniel Rosenberg43549942018-08-20 19:21:43 -07001772 if ((*flags & SB_RDONLY) && test_opt(sbi, DISABLE_CHECKPOINT)) {
1773 err = -EINVAL;
Joe Perchesdcbb4c12019-06-18 17:48:42 +08001774 f2fs_warn(sbi, "disabling checkpoint not compatible with read-only");
Daniel Rosenberg43549942018-08-20 19:21:43 -07001775 goto restore_opts;
1776 }
1777
Namjae Jeon696c0182013-06-16 09:48:48 +09001778 /*
1779 * We stop the GC thread if FS is mounted as RO
1780 * or if background_gc = off is passed in mount
1781 * option. Also sync the filesystem.
1782 */
Chao Yubbbc34f2020-02-14 17:44:13 +08001783 if ((*flags & SB_RDONLY) ||
1784 F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_OFF) {
Namjae Jeon696c0182013-06-16 09:48:48 +09001785 if (sbi->gc_thread) {
Chao Yu4d57b862018-05-30 00:20:41 +08001786 f2fs_stop_gc_thread(sbi);
Gu Zheng876dc592014-04-11 17:50:00 +08001787 need_restart_gc = true;
Namjae Jeon696c0182013-06-16 09:48:48 +09001788 }
Chao Yuaba291b2014-11-18 11:17:20 +08001789 } else if (!sbi->gc_thread) {
Chao Yu4d57b862018-05-30 00:20:41 +08001790 err = f2fs_start_gc_thread(sbi);
Namjae Jeon696c0182013-06-16 09:48:48 +09001791 if (err)
1792 goto restore_opts;
Gu Zheng876dc592014-04-11 17:50:00 +08001793 need_stop_gc = true;
1794 }
1795
Chao Yu63189b72018-03-08 14:22:56 +08001796 if (*flags & SB_RDONLY ||
1797 F2FS_OPTION(sbi).whint_mode != org_mount_opt.whint_mode) {
Jaegeuk Kimfaa0e552016-03-24 10:29:39 -07001798 writeback_inodes_sb(sb, WB_REASON_SYNC);
1799 sync_inodes_sb(sb);
1800
1801 set_sbi_flag(sbi, SBI_IS_DIRTY);
1802 set_sbi_flag(sbi, SBI_IS_CLOSE);
1803 f2fs_sync_fs(sb, 1);
1804 clear_sbi_flag(sbi, SBI_IS_CLOSE);
1805 }
1806
Daniel Rosenberg43549942018-08-20 19:21:43 -07001807 if (checkpoint_changed) {
1808 if (test_opt(sbi, DISABLE_CHECKPOINT)) {
1809 err = f2fs_disable_checkpoint(sbi);
1810 if (err)
1811 goto restore_gc;
1812 } else {
1813 f2fs_enable_checkpoint(sbi);
1814 }
1815 }
1816
Gu Zheng876dc592014-04-11 17:50:00 +08001817 /*
1818 * We stop issue flush thread if FS is mounted as RO
1819 * or if flush_merge is not passed in mount option.
1820 */
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001821 if ((*flags & SB_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {
Jaegeuk Kim5eba8c52016-12-07 16:23:32 -08001822 clear_opt(sbi, FLUSH_MERGE);
Chao Yu4d57b862018-05-30 00:20:41 +08001823 f2fs_destroy_flush_cmd_control(sbi, false);
Jaegeuk Kim5eba8c52016-12-07 16:23:32 -08001824 } else {
Chao Yu4d57b862018-05-30 00:20:41 +08001825 err = f2fs_create_flush_cmd_control(sbi);
Gu Zheng2163d192014-04-27 14:21:33 +08001826 if (err)
Gu Zhenga688b9d9e2014-04-27 14:21:21 +08001827 goto restore_gc;
Namjae Jeon696c0182013-06-16 09:48:48 +09001828 }
1829skip:
Chao Yu4b2414d2017-08-08 10:54:31 +08001830#ifdef CONFIG_QUOTA
1831 /* Release old quota file names */
1832 for (i = 0; i < MAXQUOTAS; i++)
Jaegeuk Kim52225952018-12-13 18:38:33 -08001833 kvfree(org_mount_opt.s_qf_names[i]);
Chao Yu4b2414d2017-08-08 10:54:31 +08001834#endif
Namjae Jeon696c0182013-06-16 09:48:48 +09001835 /* Update the POSIXACL Flag */
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001836 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
1837 (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07001838
Jaegeuk Kim7e65be42017-12-27 15:05:52 -08001839 limit_reserve_root(sbi);
Jaegeuk Kim095680f2018-09-28 00:24:39 -07001840 *flags = (*flags & ~SB_LAZYTIME) | (sb->s_flags & SB_LAZYTIME);
Namjae Jeon696c0182013-06-16 09:48:48 +09001841 return 0;
Gu Zheng876dc592014-04-11 17:50:00 +08001842restore_gc:
1843 if (need_restart_gc) {
Chao Yu4d57b862018-05-30 00:20:41 +08001844 if (f2fs_start_gc_thread(sbi))
Joe Perchesdcbb4c12019-06-18 17:48:42 +08001845 f2fs_warn(sbi, "background gc thread has stopped");
Gu Zheng876dc592014-04-11 17:50:00 +08001846 } else if (need_stop_gc) {
Chao Yu4d57b862018-05-30 00:20:41 +08001847 f2fs_stop_gc_thread(sbi);
Gu Zheng876dc592014-04-11 17:50:00 +08001848 }
Namjae Jeon696c0182013-06-16 09:48:48 +09001849restore_opts:
Chao Yu4b2414d2017-08-08 10:54:31 +08001850#ifdef CONFIG_QUOTA
Chao Yu63189b72018-03-08 14:22:56 +08001851 F2FS_OPTION(sbi).s_jquota_fmt = org_mount_opt.s_jquota_fmt;
Chao Yu4b2414d2017-08-08 10:54:31 +08001852 for (i = 0; i < MAXQUOTAS; i++) {
Jaegeuk Kim52225952018-12-13 18:38:33 -08001853 kvfree(F2FS_OPTION(sbi).s_qf_names[i]);
Chao Yu63189b72018-03-08 14:22:56 +08001854 F2FS_OPTION(sbi).s_qf_names[i] = org_mount_opt.s_qf_names[i];
Chao Yu4b2414d2017-08-08 10:54:31 +08001855 }
1856#endif
Namjae Jeon696c0182013-06-16 09:48:48 +09001857 sbi->mount_opt = org_mount_opt;
Chao Yu0abd6752017-07-09 00:13:07 +08001858 sb->s_flags = old_sb_flags;
Namjae Jeon696c0182013-06-16 09:48:48 +09001859 return err;
1860}
1861
Chao Yu0abd6752017-07-09 00:13:07 +08001862#ifdef CONFIG_QUOTA
1863/* Read data from quotafile */
1864static ssize_t f2fs_quota_read(struct super_block *sb, int type, char *data,
1865 size_t len, loff_t off)
1866{
1867 struct inode *inode = sb_dqopt(sb)->files[type];
1868 struct address_space *mapping = inode->i_mapping;
1869 block_t blkidx = F2FS_BYTES_TO_BLK(off);
1870 int offset = off & (sb->s_blocksize - 1);
1871 int tocopy;
1872 size_t toread;
1873 loff_t i_size = i_size_read(inode);
1874 struct page *page;
1875 char *kaddr;
1876
1877 if (off > i_size)
1878 return 0;
1879
1880 if (off + len > i_size)
1881 len = i_size - off;
1882 toread = len;
1883 while (toread > 0) {
1884 tocopy = min_t(unsigned long, sb->s_blocksize - offset, toread);
1885repeat:
Ritesh Harjani02117b82018-03-16 18:53:53 +05301886 page = read_cache_page_gfp(mapping, blkidx, GFP_NOFS);
Jaegeuk Kim4e46a022017-10-19 09:43:56 -07001887 if (IS_ERR(page)) {
1888 if (PTR_ERR(page) == -ENOMEM) {
Chao Yu5df7731f2020-02-17 17:45:44 +08001889 congestion_wait(BLK_RW_ASYNC,
1890 DEFAULT_IO_TIMEOUT);
Jaegeuk Kim4e46a022017-10-19 09:43:56 -07001891 goto repeat;
1892 }
Chao Yuaf033b22018-09-20 20:05:00 +08001893 set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
Chao Yu0abd6752017-07-09 00:13:07 +08001894 return PTR_ERR(page);
Jaegeuk Kim4e46a022017-10-19 09:43:56 -07001895 }
Chao Yu0abd6752017-07-09 00:13:07 +08001896
1897 lock_page(page);
1898
1899 if (unlikely(page->mapping != mapping)) {
1900 f2fs_put_page(page, 1);
1901 goto repeat;
1902 }
1903 if (unlikely(!PageUptodate(page))) {
1904 f2fs_put_page(page, 1);
Chao Yuaf033b22018-09-20 20:05:00 +08001905 set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
Chao Yu0abd6752017-07-09 00:13:07 +08001906 return -EIO;
1907 }
1908
1909 kaddr = kmap_atomic(page);
1910 memcpy(data, kaddr + offset, tocopy);
1911 kunmap_atomic(kaddr);
1912 f2fs_put_page(page, 1);
1913
1914 offset = 0;
1915 toread -= tocopy;
1916 data += tocopy;
1917 blkidx++;
1918 }
1919 return len;
1920}
1921
1922/* Write to quotafile */
1923static ssize_t f2fs_quota_write(struct super_block *sb, int type,
1924 const char *data, size_t len, loff_t off)
1925{
1926 struct inode *inode = sb_dqopt(sb)->files[type];
1927 struct address_space *mapping = inode->i_mapping;
1928 const struct address_space_operations *a_ops = mapping->a_ops;
1929 int offset = off & (sb->s_blocksize - 1);
1930 size_t towrite = len;
1931 struct page *page;
Chao Yu62f63ee2020-03-19 19:58:00 +08001932 void *fsdata = NULL;
Chao Yu0abd6752017-07-09 00:13:07 +08001933 char *kaddr;
1934 int err = 0;
1935 int tocopy;
1936
1937 while (towrite > 0) {
1938 tocopy = min_t(unsigned long, sb->s_blocksize - offset,
1939 towrite);
Jaegeuk Kim4e46a022017-10-19 09:43:56 -07001940retry:
Chao Yu0abd6752017-07-09 00:13:07 +08001941 err = a_ops->write_begin(NULL, mapping, off, tocopy, 0,
Chao Yu62f63ee2020-03-19 19:58:00 +08001942 &page, &fsdata);
Jaegeuk Kim4e46a022017-10-19 09:43:56 -07001943 if (unlikely(err)) {
1944 if (err == -ENOMEM) {
Chao Yu5df7731f2020-02-17 17:45:44 +08001945 congestion_wait(BLK_RW_ASYNC,
1946 DEFAULT_IO_TIMEOUT);
Jaegeuk Kim4e46a022017-10-19 09:43:56 -07001947 goto retry;
1948 }
Chao Yuaf033b22018-09-20 20:05:00 +08001949 set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
Chao Yu0abd6752017-07-09 00:13:07 +08001950 break;
Jaegeuk Kim4e46a022017-10-19 09:43:56 -07001951 }
Chao Yu0abd6752017-07-09 00:13:07 +08001952
1953 kaddr = kmap_atomic(page);
1954 memcpy(kaddr + offset, data, tocopy);
1955 kunmap_atomic(kaddr);
1956 flush_dcache_page(page);
1957
1958 a_ops->write_end(NULL, mapping, off, tocopy, tocopy,
Chao Yu62f63ee2020-03-19 19:58:00 +08001959 page, fsdata);
Chao Yu0abd6752017-07-09 00:13:07 +08001960 offset = 0;
1961 towrite -= tocopy;
1962 off += tocopy;
1963 data += tocopy;
1964 cond_resched();
1965 }
1966
1967 if (len == towrite)
Jaegeuk Kim6e5b5d42017-10-19 12:07:11 -07001968 return err;
Chao Yu0abd6752017-07-09 00:13:07 +08001969 inode->i_mtime = inode->i_ctime = current_time(inode);
1970 f2fs_mark_inode_dirty_sync(inode, false);
1971 return len - towrite;
1972}
1973
1974static struct dquot **f2fs_get_dquots(struct inode *inode)
1975{
1976 return F2FS_I(inode)->i_dquot;
1977}
1978
1979static qsize_t *f2fs_get_reserved_space(struct inode *inode)
1980{
1981 return &F2FS_I(inode)->i_reserved_quota;
1982}
1983
Chao Yu4b2414d2017-08-08 10:54:31 +08001984static int f2fs_quota_on_mount(struct f2fs_sb_info *sbi, int type)
1985{
Chao Yuaf033b22018-09-20 20:05:00 +08001986 if (is_set_ckpt_flags(sbi, CP_QUOTA_NEED_FSCK_FLAG)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08001987 f2fs_err(sbi, "quota sysfile may be corrupted, skip loading it");
Chao Yuaf033b22018-09-20 20:05:00 +08001988 return 0;
1989 }
1990
Chao Yu63189b72018-03-08 14:22:56 +08001991 return dquot_quota_on_mount(sbi->sb, F2FS_OPTION(sbi).s_qf_names[type],
1992 F2FS_OPTION(sbi).s_jquota_fmt, type);
Chao Yu4b2414d2017-08-08 10:54:31 +08001993}
1994
Jaegeuk Kimea676732017-10-06 09:14:28 -07001995int f2fs_enable_quota_files(struct f2fs_sb_info *sbi, bool rdonly)
Chao Yu4b2414d2017-08-08 10:54:31 +08001996{
Jaegeuk Kimea676732017-10-06 09:14:28 -07001997 int enabled = 0;
1998 int i, err;
1999
Chao Yu7beb01f2018-10-24 18:34:26 +08002000 if (f2fs_sb_has_quota_ino(sbi) && rdonly) {
Jaegeuk Kimea676732017-10-06 09:14:28 -07002001 err = f2fs_enable_quotas(sbi->sb);
2002 if (err) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002003 f2fs_err(sbi, "Cannot turn on quota_ino: %d", err);
Jaegeuk Kimea676732017-10-06 09:14:28 -07002004 return 0;
2005 }
2006 return 1;
2007 }
Chao Yu4b2414d2017-08-08 10:54:31 +08002008
2009 for (i = 0; i < MAXQUOTAS; i++) {
Chao Yu63189b72018-03-08 14:22:56 +08002010 if (F2FS_OPTION(sbi).s_qf_names[i]) {
Jaegeuk Kimea676732017-10-06 09:14:28 -07002011 err = f2fs_quota_on_mount(sbi, i);
2012 if (!err) {
2013 enabled = 1;
2014 continue;
2015 }
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002016 f2fs_err(sbi, "Cannot turn on quotas: %d on %d",
2017 err, i);
Chao Yu4b2414d2017-08-08 10:54:31 +08002018 }
2019 }
Jaegeuk Kimea676732017-10-06 09:14:28 -07002020 return enabled;
2021}
2022
2023static int f2fs_quota_enable(struct super_block *sb, int type, int format_id,
2024 unsigned int flags)
2025{
2026 struct inode *qf_inode;
2027 unsigned long qf_inum;
2028 int err;
2029
Chao Yu7beb01f2018-10-24 18:34:26 +08002030 BUG_ON(!f2fs_sb_has_quota_ino(F2FS_SB(sb)));
Jaegeuk Kimea676732017-10-06 09:14:28 -07002031
2032 qf_inum = f2fs_qf_ino(sb, type);
2033 if (!qf_inum)
2034 return -EPERM;
2035
2036 qf_inode = f2fs_iget(sb, qf_inum);
2037 if (IS_ERR(qf_inode)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002038 f2fs_err(F2FS_SB(sb), "Bad quota inode %u:%lu", type, qf_inum);
Jaegeuk Kimea676732017-10-06 09:14:28 -07002039 return PTR_ERR(qf_inode);
2040 }
2041
2042 /* Don't account quota for quota files to avoid recursion */
2043 qf_inode->i_flags |= S_NOQUOTA;
Jan Kara7212b952019-11-01 18:55:38 +01002044 err = dquot_load_quota_inode(qf_inode, type, format_id, flags);
Jaegeuk Kimea676732017-10-06 09:14:28 -07002045 iput(qf_inode);
2046 return err;
2047}
2048
2049static int f2fs_enable_quotas(struct super_block *sb)
2050{
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002051 struct f2fs_sb_info *sbi = F2FS_SB(sb);
Jaegeuk Kimea676732017-10-06 09:14:28 -07002052 int type, err = 0;
2053 unsigned long qf_inum;
2054 bool quota_mopt[MAXQUOTAS] = {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002055 test_opt(sbi, USRQUOTA),
2056 test_opt(sbi, GRPQUOTA),
2057 test_opt(sbi, PRJQUOTA),
Jaegeuk Kimea676732017-10-06 09:14:28 -07002058 };
2059
Chao Yuaf033b22018-09-20 20:05:00 +08002060 if (is_set_ckpt_flags(F2FS_SB(sb), CP_QUOTA_NEED_FSCK_FLAG)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002061 f2fs_err(sbi, "quota file may be corrupted, skip loading it");
Chao Yuaf033b22018-09-20 20:05:00 +08002062 return 0;
2063 }
2064
2065 sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE;
2066
Jaegeuk Kimea676732017-10-06 09:14:28 -07002067 for (type = 0; type < MAXQUOTAS; type++) {
2068 qf_inum = f2fs_qf_ino(sb, type);
2069 if (qf_inum) {
2070 err = f2fs_quota_enable(sb, type, QFMT_VFS_V1,
2071 DQUOT_USAGE_ENABLED |
2072 (quota_mopt[type] ? DQUOT_LIMITS_ENABLED : 0));
2073 if (err) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002074 f2fs_err(sbi, "Failed to enable quota tracking (type=%d, err=%d). Please run fsck to fix.",
2075 type, err);
Jaegeuk Kimea676732017-10-06 09:14:28 -07002076 for (type--; type >= 0; type--)
2077 dquot_quota_off(sb, type);
Chao Yuaf033b22018-09-20 20:05:00 +08002078 set_sbi_flag(F2FS_SB(sb),
2079 SBI_QUOTA_NEED_REPAIR);
Jaegeuk Kimea676732017-10-06 09:14:28 -07002080 return err;
2081 }
2082 }
2083 }
2084 return 0;
Chao Yu4b2414d2017-08-08 10:54:31 +08002085}
2086
Chao Yuaf033b22018-09-20 20:05:00 +08002087int f2fs_quota_sync(struct super_block *sb, int type)
Chao Yu0abd6752017-07-09 00:13:07 +08002088{
Chao Yuaf033b22018-09-20 20:05:00 +08002089 struct f2fs_sb_info *sbi = F2FS_SB(sb);
Chao Yu0abd6752017-07-09 00:13:07 +08002090 struct quota_info *dqopt = sb_dqopt(sb);
2091 int cnt;
2092 int ret;
2093
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07002094 /*
2095 * do_quotactl
2096 * f2fs_quota_sync
2097 * down_read(quota_sem)
2098 * dquot_writeback_dquots()
2099 * f2fs_dquot_commit
2100 * block_operation
2101 * down_read(quota_sem)
2102 */
2103 f2fs_lock_op(sbi);
2104
2105 down_read(&sbi->quota_sem);
Chao Yu0abd6752017-07-09 00:13:07 +08002106 ret = dquot_writeback_dquots(sb, type);
2107 if (ret)
Chao Yuaf033b22018-09-20 20:05:00 +08002108 goto out;
Chao Yu0abd6752017-07-09 00:13:07 +08002109
2110 /*
2111 * Now when everything is written we can discard the pagecache so
2112 * that userspace sees the changes.
2113 */
2114 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Chao Yuaf033b22018-09-20 20:05:00 +08002115 struct address_space *mapping;
2116
Chao Yu0abd6752017-07-09 00:13:07 +08002117 if (type != -1 && cnt != type)
2118 continue;
2119 if (!sb_has_quota_active(sb, cnt))
2120 continue;
2121
Chao Yuaf033b22018-09-20 20:05:00 +08002122 mapping = dqopt->files[cnt]->i_mapping;
2123
2124 ret = filemap_fdatawrite(mapping);
Chao Yu0abd6752017-07-09 00:13:07 +08002125 if (ret)
Chao Yuaf033b22018-09-20 20:05:00 +08002126 goto out;
2127
2128 /* if we are using journalled quota */
2129 if (is_journalled_quota(sbi))
2130 continue;
2131
2132 ret = filemap_fdatawait(mapping);
2133 if (ret)
2134 set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
Chao Yu0abd6752017-07-09 00:13:07 +08002135
2136 inode_lock(dqopt->files[cnt]);
2137 truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
2138 inode_unlock(dqopt->files[cnt]);
2139 }
Chao Yuaf033b22018-09-20 20:05:00 +08002140out:
2141 if (ret)
2142 set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07002143 up_read(&sbi->quota_sem);
2144 f2fs_unlock_op(sbi);
Chao Yuaf033b22018-09-20 20:05:00 +08002145 return ret;
Chao Yu0abd6752017-07-09 00:13:07 +08002146}
2147
2148static int f2fs_quota_on(struct super_block *sb, int type, int format_id,
2149 const struct path *path)
2150{
2151 struct inode *inode;
2152 int err;
2153
Chao Yufe973b02019-07-25 17:33:37 +08002154 /* if quota sysfile exists, deny enabling quota with specific file */
2155 if (f2fs_sb_has_quota_ino(F2FS_SB(sb))) {
2156 f2fs_err(F2FS_SB(sb), "quota sysfile already exists");
2157 return -EBUSY;
2158 }
2159
Chao Yu9a20d392017-08-07 16:37:59 +08002160 err = f2fs_quota_sync(sb, type);
Chao Yu0abd6752017-07-09 00:13:07 +08002161 if (err)
2162 return err;
2163
2164 err = dquot_quota_on(sb, type, format_id, path);
2165 if (err)
2166 return err;
2167
2168 inode = d_inode(path->dentry);
2169
2170 inode_lock(inode);
Chao Yu59c84402018-04-03 15:08:17 +08002171 F2FS_I(inode)->i_flags |= F2FS_NOATIME_FL | F2FS_IMMUTABLE_FL;
Chao Yu9149a5e2018-10-07 19:06:15 +08002172 f2fs_set_inode_flags(inode);
Chao Yu0abd6752017-07-09 00:13:07 +08002173 inode_unlock(inode);
2174 f2fs_mark_inode_dirty_sync(inode, false);
2175
2176 return 0;
2177}
2178
Chao Yufe973b02019-07-25 17:33:37 +08002179static int __f2fs_quota_off(struct super_block *sb, int type)
Chao Yu0abd6752017-07-09 00:13:07 +08002180{
2181 struct inode *inode = sb_dqopt(sb)->files[type];
2182 int err;
2183
2184 if (!inode || !igrab(inode))
2185 return dquot_quota_off(sb, type);
2186
Yunlei Hecda9cc52018-06-26 13:12:43 +08002187 err = f2fs_quota_sync(sb, type);
2188 if (err)
2189 goto out_put;
Chao Yu0abd6752017-07-09 00:13:07 +08002190
2191 err = dquot_quota_off(sb, type);
Chao Yu7beb01f2018-10-24 18:34:26 +08002192 if (err || f2fs_sb_has_quota_ino(F2FS_SB(sb)))
Chao Yu0abd6752017-07-09 00:13:07 +08002193 goto out_put;
2194
2195 inode_lock(inode);
Chao Yu59c84402018-04-03 15:08:17 +08002196 F2FS_I(inode)->i_flags &= ~(F2FS_NOATIME_FL | F2FS_IMMUTABLE_FL);
Chao Yu9149a5e2018-10-07 19:06:15 +08002197 f2fs_set_inode_flags(inode);
Chao Yu0abd6752017-07-09 00:13:07 +08002198 inode_unlock(inode);
2199 f2fs_mark_inode_dirty_sync(inode, false);
2200out_put:
2201 iput(inode);
2202 return err;
2203}
2204
Chao Yufe973b02019-07-25 17:33:37 +08002205static int f2fs_quota_off(struct super_block *sb, int type)
2206{
2207 struct f2fs_sb_info *sbi = F2FS_SB(sb);
2208 int err;
2209
2210 err = __f2fs_quota_off(sb, type);
2211
2212 /*
2213 * quotactl can shutdown journalled quota, result in inconsistence
2214 * between quota record and fs data by following updates, tag the
2215 * flag to let fsck be aware of it.
2216 */
2217 if (is_journalled_quota(sbi))
2218 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
2219 return err;
2220}
2221
Chao Yu4b2414d2017-08-08 10:54:31 +08002222void f2fs_quota_off_umount(struct super_block *sb)
Chao Yu0abd6752017-07-09 00:13:07 +08002223{
2224 int type;
Yunlei Hecda9cc52018-06-26 13:12:43 +08002225 int err;
Chao Yu0abd6752017-07-09 00:13:07 +08002226
Yunlei Hecda9cc52018-06-26 13:12:43 +08002227 for (type = 0; type < MAXQUOTAS; type++) {
Chao Yufe973b02019-07-25 17:33:37 +08002228 err = __f2fs_quota_off(sb, type);
Yunlei Hecda9cc52018-06-26 13:12:43 +08002229 if (err) {
2230 int ret = dquot_quota_off(sb, type);
2231
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002232 f2fs_err(F2FS_SB(sb), "Fail to turn off disk quota (type: %d, err: %d, ret:%d), Please run fsck to fix it.",
2233 type, err, ret);
Chao Yuaf033b22018-09-20 20:05:00 +08002234 set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
Yunlei Hecda9cc52018-06-26 13:12:43 +08002235 }
2236 }
Jaegeuk Kim0e0667b2019-01-27 17:59:53 -08002237 /*
2238 * In case of checkpoint=disable, we must flush quota blocks.
2239 * This can cause NULL exception for node_inode in end_io, since
2240 * put_super already dropped it.
2241 */
2242 sync_filesystem(sb);
Chao Yu0abd6752017-07-09 00:13:07 +08002243}
2244
Sheng Yong26b5a072018-10-12 18:49:26 +08002245static void f2fs_truncate_quota_inode_pages(struct super_block *sb)
2246{
2247 struct quota_info *dqopt = sb_dqopt(sb);
2248 int type;
2249
2250 for (type = 0; type < MAXQUOTAS; type++) {
2251 if (!dqopt->files[type])
2252 continue;
2253 f2fs_inode_synced(dqopt->files[type]);
2254 }
2255}
2256
Chao Yuaf033b22018-09-20 20:05:00 +08002257static int f2fs_dquot_commit(struct dquot *dquot)
2258{
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07002259 struct f2fs_sb_info *sbi = F2FS_SB(dquot->dq_sb);
Chao Yuaf033b22018-09-20 20:05:00 +08002260 int ret;
2261
Jaegeuk Kim2c4e0c52019-12-03 17:31:00 -08002262 down_read_nested(&sbi->quota_sem, SINGLE_DEPTH_NESTING);
Chao Yuaf033b22018-09-20 20:05:00 +08002263 ret = dquot_commit(dquot);
2264 if (ret < 0)
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07002265 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
2266 up_read(&sbi->quota_sem);
Chao Yuaf033b22018-09-20 20:05:00 +08002267 return ret;
2268}
2269
2270static int f2fs_dquot_acquire(struct dquot *dquot)
2271{
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07002272 struct f2fs_sb_info *sbi = F2FS_SB(dquot->dq_sb);
Chao Yuaf033b22018-09-20 20:05:00 +08002273 int ret;
2274
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07002275 down_read(&sbi->quota_sem);
Chao Yuaf033b22018-09-20 20:05:00 +08002276 ret = dquot_acquire(dquot);
2277 if (ret < 0)
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07002278 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
2279 up_read(&sbi->quota_sem);
Chao Yuaf033b22018-09-20 20:05:00 +08002280 return ret;
2281}
2282
2283static int f2fs_dquot_release(struct dquot *dquot)
2284{
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07002285 struct f2fs_sb_info *sbi = F2FS_SB(dquot->dq_sb);
Jaegeuk Kim2c4e0c52019-12-03 17:31:00 -08002286 int ret = dquot_release(dquot);
Chao Yuaf033b22018-09-20 20:05:00 +08002287
Chao Yuaf033b22018-09-20 20:05:00 +08002288 if (ret < 0)
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07002289 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
Chao Yuaf033b22018-09-20 20:05:00 +08002290 return ret;
2291}
2292
2293static int f2fs_dquot_mark_dquot_dirty(struct dquot *dquot)
2294{
2295 struct super_block *sb = dquot->dq_sb;
2296 struct f2fs_sb_info *sbi = F2FS_SB(sb);
Jaegeuk Kim2c4e0c52019-12-03 17:31:00 -08002297 int ret = dquot_mark_dquot_dirty(dquot);
Chao Yuaf033b22018-09-20 20:05:00 +08002298
2299 /* if we are using journalled quota */
2300 if (is_journalled_quota(sbi))
2301 set_sbi_flag(sbi, SBI_QUOTA_NEED_FLUSH);
2302
2303 return ret;
2304}
2305
2306static int f2fs_dquot_commit_info(struct super_block *sb, int type)
2307{
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07002308 struct f2fs_sb_info *sbi = F2FS_SB(sb);
Jaegeuk Kim2c4e0c52019-12-03 17:31:00 -08002309 int ret = dquot_commit_info(sb, type);
Chao Yuaf033b22018-09-20 20:05:00 +08002310
Chao Yuaf033b22018-09-20 20:05:00 +08002311 if (ret < 0)
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07002312 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
Chao Yuaf033b22018-09-20 20:05:00 +08002313 return ret;
2314}
Sheng Yong26b5a072018-10-12 18:49:26 +08002315
Wei Yongjun94b1e102018-01-05 09:41:20 +00002316static int f2fs_get_projid(struct inode *inode, kprojid_t *projid)
Chao Yu5c571322017-07-26 00:01:41 +08002317{
2318 *projid = F2FS_I(inode)->i_projid;
2319 return 0;
2320}
2321
Chao Yu0abd6752017-07-09 00:13:07 +08002322static const struct dquot_operations f2fs_quota_operations = {
2323 .get_reserved_space = f2fs_get_reserved_space,
Chao Yuaf033b22018-09-20 20:05:00 +08002324 .write_dquot = f2fs_dquot_commit,
2325 .acquire_dquot = f2fs_dquot_acquire,
2326 .release_dquot = f2fs_dquot_release,
2327 .mark_dirty = f2fs_dquot_mark_dquot_dirty,
2328 .write_info = f2fs_dquot_commit_info,
Chao Yu0abd6752017-07-09 00:13:07 +08002329 .alloc_dquot = dquot_alloc,
2330 .destroy_dquot = dquot_destroy,
Chao Yu5c571322017-07-26 00:01:41 +08002331 .get_projid = f2fs_get_projid,
Chao Yu0abd6752017-07-09 00:13:07 +08002332 .get_next_id = dquot_get_next_id,
2333};
2334
2335static const struct quotactl_ops f2fs_quotactl_ops = {
2336 .quota_on = f2fs_quota_on,
2337 .quota_off = f2fs_quota_off,
2338 .quota_sync = f2fs_quota_sync,
2339 .get_state = dquot_get_state,
2340 .set_info = dquot_set_dqinfo,
2341 .get_dqblk = dquot_get_dqblk,
2342 .set_dqblk = dquot_set_dqblk,
2343 .get_nextdqblk = dquot_get_next_dqblk,
2344};
2345#else
Chao Yuaf033b22018-09-20 20:05:00 +08002346int f2fs_quota_sync(struct super_block *sb, int type)
2347{
2348 return 0;
2349}
2350
Chao Yu4b2414d2017-08-08 10:54:31 +08002351void f2fs_quota_off_umount(struct super_block *sb)
Chao Yu0abd6752017-07-09 00:13:07 +08002352{
2353}
2354#endif
2355
Arvind Yadavf62fc9f2017-08-31 15:06:24 +05302356static const struct super_operations f2fs_sops = {
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002357 .alloc_inode = f2fs_alloc_inode,
Al Virod01718a2019-04-15 19:29:14 -04002358 .free_inode = f2fs_free_inode,
Jaegeuk Kim531ad7d2013-04-30 11:33:27 +09002359 .drop_inode = f2fs_drop_inode,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002360 .write_inode = f2fs_write_inode,
Jaegeuk Kimb3783872013-06-10 09:17:01 +09002361 .dirty_inode = f2fs_dirty_inode,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002362 .show_options = f2fs_show_options,
Chao Yu0abd6752017-07-09 00:13:07 +08002363#ifdef CONFIG_QUOTA
2364 .quota_read = f2fs_quota_read,
2365 .quota_write = f2fs_quota_write,
2366 .get_dquots = f2fs_get_dquots,
2367#endif
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002368 .evict_inode = f2fs_evict_inode,
2369 .put_super = f2fs_put_super,
2370 .sync_fs = f2fs_sync_fs,
Changman Leed6212a52013-01-29 18:30:07 +09002371 .freeze_fs = f2fs_freeze,
2372 .unfreeze_fs = f2fs_unfreeze,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002373 .statfs = f2fs_statfs,
Namjae Jeon696c0182013-06-16 09:48:48 +09002374 .remount_fs = f2fs_remount,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002375};
2376
Chandan Rajendra643fa962018-12-12 15:20:12 +05302377#ifdef CONFIG_FS_ENCRYPTION
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07002378static int f2fs_get_context(struct inode *inode, void *ctx, size_t len)
2379{
2380 return f2fs_getxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,
2381 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,
2382 ctx, len, NULL);
2383}
2384
2385static int f2fs_set_context(struct inode *inode, const void *ctx, size_t len,
2386 void *fs_data)
2387{
Sheng Yongb7c409d2018-03-15 18:51:41 +08002388 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2389
2390 /*
2391 * Encrypting the root directory is not allowed because fsck
2392 * expects lost+found directory to exist and remain unencrypted
2393 * if LOST_FOUND feature is enabled.
2394 *
2395 */
Chao Yu7beb01f2018-10-24 18:34:26 +08002396 if (f2fs_sb_has_lost_found(sbi) &&
Sheng Yongb7c409d2018-03-15 18:51:41 +08002397 inode->i_ino == F2FS_ROOT_INO(sbi))
2398 return -EPERM;
2399
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07002400 return f2fs_setxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,
2401 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,
2402 ctx, len, fs_data, XATTR_CREATE);
2403}
2404
Sheng Yongff62af22018-03-15 18:51:42 +08002405static bool f2fs_dummy_context(struct inode *inode)
2406{
2407 return DUMMY_ENCRYPTION_ENABLED(F2FS_I_SB(inode));
2408}
2409
Eric Biggers0eee17e2019-10-24 14:54:38 -07002410static bool f2fs_has_stable_inodes(struct super_block *sb)
2411{
2412 return true;
2413}
2414
2415static void f2fs_get_ino_and_lblk_bits(struct super_block *sb,
2416 int *ino_bits_ret, int *lblk_bits_ret)
2417{
2418 *ino_bits_ret = 8 * sizeof(nid_t);
2419 *lblk_bits_ret = 8 * sizeof(block_t);
2420}
2421
Eric Biggers6f69f0e2017-02-07 12:42:10 -08002422static const struct fscrypt_operations f2fs_cryptops = {
Eric Biggers0eee17e2019-10-24 14:54:38 -07002423 .key_prefix = "f2fs:",
2424 .get_context = f2fs_get_context,
2425 .set_context = f2fs_set_context,
2426 .dummy_context = f2fs_dummy_context,
2427 .empty_dir = f2fs_empty_dir,
2428 .max_namelen = F2FS_NAME_LEN,
2429 .has_stable_inodes = f2fs_has_stable_inodes,
2430 .get_ino_and_lblk_bits = f2fs_get_ino_and_lblk_bits,
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07002431};
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07002432#endif
2433
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002434static struct inode *f2fs_nfs_get_inode(struct super_block *sb,
2435 u64 ino, u32 generation)
2436{
2437 struct f2fs_sb_info *sbi = F2FS_SB(sb);
2438 struct inode *inode;
2439
Chao Yu4d57b862018-05-30 00:20:41 +08002440 if (f2fs_check_nid_range(sbi, ino))
Chao Yu910bb122014-03-12 17:08:36 +08002441 return ERR_PTR(-ESTALE);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002442
2443 /*
2444 * f2fs_iget isn't quite right if the inode is currently unallocated!
2445 * However f2fs_iget currently does appropriate checks to handle stale
2446 * inodes so everything is OK.
2447 */
2448 inode = f2fs_iget(sb, ino);
2449 if (IS_ERR(inode))
2450 return ERR_CAST(inode);
Jaegeuk Kim6bacf522013-12-06 15:00:58 +09002451 if (unlikely(generation && inode->i_generation != generation)) {
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002452 /* we didn't find the right inode.. */
2453 iput(inode);
2454 return ERR_PTR(-ESTALE);
2455 }
2456 return inode;
2457}
2458
2459static struct dentry *f2fs_fh_to_dentry(struct super_block *sb, struct fid *fid,
2460 int fh_len, int fh_type)
2461{
2462 return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
2463 f2fs_nfs_get_inode);
2464}
2465
2466static struct dentry *f2fs_fh_to_parent(struct super_block *sb, struct fid *fid,
2467 int fh_len, int fh_type)
2468{
2469 return generic_fh_to_parent(sb, fid, fh_len, fh_type,
2470 f2fs_nfs_get_inode);
2471}
2472
2473static const struct export_operations f2fs_export_ops = {
2474 .fh_to_dentry = f2fs_fh_to_dentry,
2475 .fh_to_parent = f2fs_fh_to_parent,
2476 .get_parent = f2fs_get_parent,
2477};
2478
Chao Yue0afc4d2015-12-31 14:35:37 +08002479static loff_t max_file_blocks(void)
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002480{
Chao Yu7a2af762017-07-19 00:19:06 +08002481 loff_t result = 0;
Chao Yud02a6e62019-03-25 21:08:19 +08002482 loff_t leaf_count = DEF_ADDRS_PER_BLOCK;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002483
Chao Yu7a2af762017-07-19 00:19:06 +08002484 /*
2485 * note: previously, result is equal to (DEF_ADDRS_PER_INODE -
Chao Yu6afc6622017-09-06 21:59:50 +08002486 * DEFAULT_INLINE_XATTR_ADDRS), but now f2fs try to reserve more
Chao Yu7a2af762017-07-19 00:19:06 +08002487 * space in inode.i_addr, it will be more safe to reassign
2488 * result as zero.
2489 */
2490
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002491 /* two direct node blocks */
2492 result += (leaf_count * 2);
2493
2494 /* two indirect node blocks */
2495 leaf_count *= NIDS_PER_BLOCK;
2496 result += (leaf_count * 2);
2497
2498 /* one double indirect node block */
2499 leaf_count *= NIDS_PER_BLOCK;
2500 result += leaf_count;
2501
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002502 return result;
2503}
2504
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002505static int __f2fs_commit_super(struct buffer_head *bh,
2506 struct f2fs_super_block *super)
Chao Yu9a59b622015-12-15 09:58:18 +08002507{
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002508 lock_buffer(bh);
2509 if (super)
2510 memcpy(bh->b_data + F2FS_SUPER_OFFSET, super, sizeof(*super));
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002511 set_buffer_dirty(bh);
2512 unlock_buffer(bh);
2513
2514 /* it's rare case, we can do fua all the time */
Jan Kara3adc5fcb2017-05-02 17:03:47 +02002515 return __sync_dirty_buffer(bh, REQ_SYNC | REQ_PREFLUSH | REQ_FUA);
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002516}
2517
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002518static inline bool sanity_check_area_boundary(struct f2fs_sb_info *sbi,
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002519 struct buffer_head *bh)
2520{
2521 struct f2fs_super_block *raw_super = (struct f2fs_super_block *)
2522 (bh->b_data + F2FS_SUPER_OFFSET);
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002523 struct super_block *sb = sbi->sb;
Chao Yu9a59b622015-12-15 09:58:18 +08002524 u32 segment0_blkaddr = le32_to_cpu(raw_super->segment0_blkaddr);
2525 u32 cp_blkaddr = le32_to_cpu(raw_super->cp_blkaddr);
2526 u32 sit_blkaddr = le32_to_cpu(raw_super->sit_blkaddr);
2527 u32 nat_blkaddr = le32_to_cpu(raw_super->nat_blkaddr);
2528 u32 ssa_blkaddr = le32_to_cpu(raw_super->ssa_blkaddr);
2529 u32 main_blkaddr = le32_to_cpu(raw_super->main_blkaddr);
2530 u32 segment_count_ckpt = le32_to_cpu(raw_super->segment_count_ckpt);
2531 u32 segment_count_sit = le32_to_cpu(raw_super->segment_count_sit);
2532 u32 segment_count_nat = le32_to_cpu(raw_super->segment_count_nat);
2533 u32 segment_count_ssa = le32_to_cpu(raw_super->segment_count_ssa);
2534 u32 segment_count_main = le32_to_cpu(raw_super->segment_count_main);
2535 u32 segment_count = le32_to_cpu(raw_super->segment_count);
2536 u32 log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002537 u64 main_end_blkaddr = main_blkaddr +
2538 (segment_count_main << log_blocks_per_seg);
2539 u64 seg_end_blkaddr = segment0_blkaddr +
2540 (segment_count << log_blocks_per_seg);
Chao Yu9a59b622015-12-15 09:58:18 +08002541
2542 if (segment0_blkaddr != cp_blkaddr) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002543 f2fs_info(sbi, "Mismatch start address, segment0(%u) cp_blkaddr(%u)",
2544 segment0_blkaddr, cp_blkaddr);
Chao Yu9a59b622015-12-15 09:58:18 +08002545 return true;
2546 }
2547
2548 if (cp_blkaddr + (segment_count_ckpt << log_blocks_per_seg) !=
2549 sit_blkaddr) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002550 f2fs_info(sbi, "Wrong CP boundary, start(%u) end(%u) blocks(%u)",
2551 cp_blkaddr, sit_blkaddr,
2552 segment_count_ckpt << log_blocks_per_seg);
Chao Yu9a59b622015-12-15 09:58:18 +08002553 return true;
2554 }
2555
2556 if (sit_blkaddr + (segment_count_sit << log_blocks_per_seg) !=
2557 nat_blkaddr) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002558 f2fs_info(sbi, "Wrong SIT boundary, start(%u) end(%u) blocks(%u)",
2559 sit_blkaddr, nat_blkaddr,
2560 segment_count_sit << log_blocks_per_seg);
Chao Yu9a59b622015-12-15 09:58:18 +08002561 return true;
2562 }
2563
2564 if (nat_blkaddr + (segment_count_nat << log_blocks_per_seg) !=
2565 ssa_blkaddr) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002566 f2fs_info(sbi, "Wrong NAT boundary, start(%u) end(%u) blocks(%u)",
2567 nat_blkaddr, ssa_blkaddr,
2568 segment_count_nat << log_blocks_per_seg);
Chao Yu9a59b622015-12-15 09:58:18 +08002569 return true;
2570 }
2571
2572 if (ssa_blkaddr + (segment_count_ssa << log_blocks_per_seg) !=
2573 main_blkaddr) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002574 f2fs_info(sbi, "Wrong SSA boundary, start(%u) end(%u) blocks(%u)",
2575 ssa_blkaddr, main_blkaddr,
2576 segment_count_ssa << log_blocks_per_seg);
Chao Yu9a59b622015-12-15 09:58:18 +08002577 return true;
2578 }
2579
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002580 if (main_end_blkaddr > seg_end_blkaddr) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002581 f2fs_info(sbi, "Wrong MAIN_AREA boundary, start(%u) end(%u) block(%u)",
2582 main_blkaddr,
2583 segment0_blkaddr +
2584 (segment_count << log_blocks_per_seg),
2585 segment_count_main << log_blocks_per_seg);
Chao Yu9a59b622015-12-15 09:58:18 +08002586 return true;
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002587 } else if (main_end_blkaddr < seg_end_blkaddr) {
2588 int err = 0;
2589 char *res;
Chao Yu9a59b622015-12-15 09:58:18 +08002590
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002591 /* fix in-memory information all the time */
2592 raw_super->segment_count = cpu_to_le32((main_end_blkaddr -
2593 segment0_blkaddr) >> log_blocks_per_seg);
2594
2595 if (f2fs_readonly(sb) || bdev_read_only(sb->s_bdev)) {
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002596 set_sbi_flag(sbi, SBI_NEED_SB_WRITE);
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002597 res = "internally";
2598 } else {
2599 err = __f2fs_commit_super(bh, NULL);
2600 res = err ? "failed" : "done";
2601 }
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002602 f2fs_info(sbi, "Fix alignment : %s, start(%u) end(%u) block(%u)",
2603 res, main_blkaddr,
2604 segment0_blkaddr +
2605 (segment_count << log_blocks_per_seg),
2606 segment_count_main << log_blocks_per_seg);
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002607 if (err)
2608 return true;
2609 }
Chao Yu9a59b622015-12-15 09:58:18 +08002610 return false;
2611}
2612
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002613static int sanity_check_raw_super(struct f2fs_sb_info *sbi,
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002614 struct buffer_head *bh)
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002615{
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002616 block_t segment_count, segs_per_sec, secs_per_zone;
2617 block_t total_sections, blocks_per_seg;
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002618 struct f2fs_super_block *raw_super = (struct f2fs_super_block *)
2619 (bh->b_data + F2FS_SUPER_OFFSET);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002620 unsigned int blocksize;
Junling Zhengd440c522018-09-28 20:25:56 +08002621 size_t crc_offset = 0;
2622 __u32 crc = 0;
2623
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002624 if (le32_to_cpu(raw_super->magic) != F2FS_SUPER_MAGIC) {
2625 f2fs_info(sbi, "Magic Mismatch, valid(0x%x) - read(0x%x)",
2626 F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic));
2627 return -EINVAL;
2628 }
2629
Junling Zhengd440c522018-09-28 20:25:56 +08002630 /* Check checksum_offset and crc in superblock */
Chao Yu7beb01f2018-10-24 18:34:26 +08002631 if (__F2FS_HAS_FEATURE(raw_super, F2FS_FEATURE_SB_CHKSUM)) {
Junling Zhengd440c522018-09-28 20:25:56 +08002632 crc_offset = le32_to_cpu(raw_super->checksum_offset);
2633 if (crc_offset !=
2634 offsetof(struct f2fs_super_block, crc)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002635 f2fs_info(sbi, "Invalid SB checksum offset: %zu",
2636 crc_offset);
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002637 return -EFSCORRUPTED;
Junling Zhengd440c522018-09-28 20:25:56 +08002638 }
2639 crc = le32_to_cpu(raw_super->crc);
2640 if (!f2fs_crc_valid(sbi, crc, raw_super, crc_offset)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002641 f2fs_info(sbi, "Invalid SB checksum value: %u", crc);
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002642 return -EFSCORRUPTED;
Junling Zhengd440c522018-09-28 20:25:56 +08002643 }
2644 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002645
majianpeng5c9b4692013-02-01 19:07:57 +08002646 /* Currently, support only 4KB page cache size */
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002647 if (F2FS_BLKSIZE != PAGE_SIZE) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002648 f2fs_info(sbi, "Invalid page_cache_size (%lu), supports only 4KB",
2649 PAGE_SIZE);
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002650 return -EFSCORRUPTED;
majianpeng5c9b4692013-02-01 19:07:57 +08002651 }
2652
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002653 /* Currently, support only 4KB block size */
2654 blocksize = 1 << le32_to_cpu(raw_super->log_blocksize);
majianpeng5c9b4692013-02-01 19:07:57 +08002655 if (blocksize != F2FS_BLKSIZE) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002656 f2fs_info(sbi, "Invalid blocksize (%u), supports only 4KB",
2657 blocksize);
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002658 return -EFSCORRUPTED;
Namjae Jeona07ef782012-12-30 14:52:05 +09002659 }
majianpeng5c9b4692013-02-01 19:07:57 +08002660
Chao Yu9a59b622015-12-15 09:58:18 +08002661 /* check log blocks per segment */
2662 if (le32_to_cpu(raw_super->log_blocks_per_seg) != 9) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002663 f2fs_info(sbi, "Invalid log blocks per segment (%u)",
2664 le32_to_cpu(raw_super->log_blocks_per_seg));
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002665 return -EFSCORRUPTED;
Chao Yu9a59b622015-12-15 09:58:18 +08002666 }
2667
Chao Yu55cf9cb2014-09-15 18:01:10 +08002668 /* Currently, support 512/1024/2048/4096 bytes sector size */
2669 if (le32_to_cpu(raw_super->log_sectorsize) >
2670 F2FS_MAX_LOG_SECTOR_SIZE ||
2671 le32_to_cpu(raw_super->log_sectorsize) <
2672 F2FS_MIN_LOG_SECTOR_SIZE) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002673 f2fs_info(sbi, "Invalid log sectorsize (%u)",
2674 le32_to_cpu(raw_super->log_sectorsize));
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002675 return -EFSCORRUPTED;
Namjae Jeona07ef782012-12-30 14:52:05 +09002676 }
Chao Yu55cf9cb2014-09-15 18:01:10 +08002677 if (le32_to_cpu(raw_super->log_sectors_per_block) +
2678 le32_to_cpu(raw_super->log_sectorsize) !=
2679 F2FS_MAX_LOG_SECTOR_SIZE) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002680 f2fs_info(sbi, "Invalid log sectors per block(%u) log sectorsize(%u)",
2681 le32_to_cpu(raw_super->log_sectors_per_block),
2682 le32_to_cpu(raw_super->log_sectorsize));
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002683 return -EFSCORRUPTED;
Namjae Jeona07ef782012-12-30 14:52:05 +09002684 }
Chao Yu9a59b622015-12-15 09:58:18 +08002685
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002686 segment_count = le32_to_cpu(raw_super->segment_count);
2687 segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
2688 secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
2689 total_sections = le32_to_cpu(raw_super->section_count);
2690
2691 /* blocks_per_seg should be 512, given the above check */
2692 blocks_per_seg = 1 << le32_to_cpu(raw_super->log_blocks_per_seg);
2693
2694 if (segment_count > F2FS_MAX_SEGMENT ||
2695 segment_count < F2FS_MIN_SEGMENTS) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002696 f2fs_info(sbi, "Invalid segment count (%u)", segment_count);
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002697 return -EFSCORRUPTED;
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002698 }
2699
2700 if (total_sections > segment_count ||
2701 total_sections < F2FS_MIN_SEGMENTS ||
2702 segs_per_sec > segment_count || !segs_per_sec) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002703 f2fs_info(sbi, "Invalid segment/section count (%u, %u x %u)",
2704 segment_count, total_sections, segs_per_sec);
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002705 return -EFSCORRUPTED;
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002706 }
2707
2708 if ((segment_count / segs_per_sec) < total_sections) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002709 f2fs_info(sbi, "Small segment_count (%u < %u * %u)",
2710 segment_count, segs_per_sec, total_sections);
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002711 return -EFSCORRUPTED;
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002712 }
2713
Martin Blumenstingl88960062018-12-22 11:22:26 +01002714 if (segment_count > (le64_to_cpu(raw_super->block_count) >> 9)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002715 f2fs_info(sbi, "Wrong segment_count / block_count (%u > %llu)",
2716 segment_count, le64_to_cpu(raw_super->block_count));
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002717 return -EFSCORRUPTED;
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002718 }
2719
Qiuyang Sun9f701f62019-09-23 12:22:35 +08002720 if (RDEV(0).path[0]) {
2721 block_t dev_seg_count = le32_to_cpu(RDEV(0).total_segments);
2722 int i = 1;
2723
2724 while (i < MAX_DEVICES && RDEV(i).path[0]) {
2725 dev_seg_count += le32_to_cpu(RDEV(i).total_segments);
2726 i++;
2727 }
2728 if (segment_count != dev_seg_count) {
2729 f2fs_info(sbi, "Segment count (%u) mismatch with total segments from devices (%u)",
2730 segment_count, dev_seg_count);
2731 return -EFSCORRUPTED;
2732 }
2733 }
2734
Chao Yu42bf5462018-06-23 00:12:36 +08002735 if (secs_per_zone > total_sections || !secs_per_zone) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002736 f2fs_info(sbi, "Wrong secs_per_zone / total_sections (%u, %u)",
2737 secs_per_zone, total_sections);
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002738 return -EFSCORRUPTED;
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002739 }
2740 if (le32_to_cpu(raw_super->extension_count) > F2FS_MAX_EXTENSION ||
2741 raw_super->hot_ext_count > F2FS_MAX_EXTENSION ||
2742 (le32_to_cpu(raw_super->extension_count) +
2743 raw_super->hot_ext_count) > F2FS_MAX_EXTENSION) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002744 f2fs_info(sbi, "Corrupted extension count (%u + %u > %u)",
2745 le32_to_cpu(raw_super->extension_count),
2746 raw_super->hot_ext_count,
2747 F2FS_MAX_EXTENSION);
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002748 return -EFSCORRUPTED;
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002749 }
2750
2751 if (le32_to_cpu(raw_super->cp_payload) >
2752 (blocks_per_seg - F2FS_CP_PACKS)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002753 f2fs_info(sbi, "Insane cp_payload (%u > %u)",
2754 le32_to_cpu(raw_super->cp_payload),
2755 blocks_per_seg - F2FS_CP_PACKS);
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002756 return -EFSCORRUPTED;
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002757 }
2758
Chao Yu9a59b622015-12-15 09:58:18 +08002759 /* check reserved ino info */
2760 if (le32_to_cpu(raw_super->node_ino) != 1 ||
2761 le32_to_cpu(raw_super->meta_ino) != 2 ||
2762 le32_to_cpu(raw_super->root_ino) != 3) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002763 f2fs_info(sbi, "Invalid Fs Meta Ino: node(%u) meta(%u) root(%u)",
2764 le32_to_cpu(raw_super->node_ino),
2765 le32_to_cpu(raw_super->meta_ino),
2766 le32_to_cpu(raw_super->root_ino));
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002767 return -EFSCORRUPTED;
Chao Yu9a59b622015-12-15 09:58:18 +08002768 }
2769
2770 /* check CP/SIT/NAT/SSA/MAIN_AREA area boundary */
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002771 if (sanity_check_area_boundary(sbi, bh))
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08002772 return -EFSCORRUPTED;
Chao Yu9a59b622015-12-15 09:58:18 +08002773
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002774 return 0;
2775}
2776
Chao Yu4d57b862018-05-30 00:20:41 +08002777int f2fs_sanity_check_ckpt(struct f2fs_sb_info *sbi)
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002778{
2779 unsigned int total, fsmeta;
Jaegeuk Kim577e3492013-01-24 19:56:11 +09002780 struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
2781 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
Jaegeuk Kim2040fce82016-12-05 13:56:04 -08002782 unsigned int ovp_segments, reserved_segments;
Jin Qian15d30422017-05-15 10:45:08 -07002783 unsigned int main_segs, blocks_per_seg;
Chao Yuc77ec612018-06-23 11:25:19 +08002784 unsigned int sit_segs, nat_segs;
2785 unsigned int sit_bitmap_size, nat_bitmap_size;
2786 unsigned int log_blocks_per_seg;
Chao Yu9dc956b2018-06-27 18:05:54 +08002787 unsigned int segment_count_main;
Chao Yue494c2f2018-08-01 19:16:11 +08002788 unsigned int cp_pack_start_sum, cp_payload;
Chao Yu7b63f722019-04-15 15:30:50 +08002789 block_t user_block_count, valid_user_blocks;
2790 block_t avail_node_count, valid_node_count;
Chao Yu042be0f2018-09-06 20:34:12 +08002791 int i, j;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002792
2793 total = le32_to_cpu(raw_super->segment_count);
2794 fsmeta = le32_to_cpu(raw_super->segment_count_ckpt);
Chao Yuc77ec612018-06-23 11:25:19 +08002795 sit_segs = le32_to_cpu(raw_super->segment_count_sit);
2796 fsmeta += sit_segs;
2797 nat_segs = le32_to_cpu(raw_super->segment_count_nat);
2798 fsmeta += nat_segs;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002799 fsmeta += le32_to_cpu(ckpt->rsvd_segment_count);
2800 fsmeta += le32_to_cpu(raw_super->segment_count_ssa);
2801
Jaegeuk Kim6bacf522013-12-06 15:00:58 +09002802 if (unlikely(fsmeta >= total))
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002803 return 1;
Jaegeuk Kim577e3492013-01-24 19:56:11 +09002804
Jaegeuk Kim2040fce82016-12-05 13:56:04 -08002805 ovp_segments = le32_to_cpu(ckpt->overprov_segment_count);
2806 reserved_segments = le32_to_cpu(ckpt->rsvd_segment_count);
2807
2808 if (unlikely(fsmeta < F2FS_MIN_SEGMENTS ||
2809 ovp_segments == 0 || reserved_segments == 0)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002810 f2fs_err(sbi, "Wrong layout: check mkfs.f2fs version");
Jaegeuk Kim2040fce82016-12-05 13:56:04 -08002811 return 1;
2812 }
2813
Chao Yu9dc956b2018-06-27 18:05:54 +08002814 user_block_count = le64_to_cpu(ckpt->user_block_count);
2815 segment_count_main = le32_to_cpu(raw_super->segment_count_main);
2816 log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
2817 if (!user_block_count || user_block_count >=
2818 segment_count_main << log_blocks_per_seg) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002819 f2fs_err(sbi, "Wrong user_block_count: %u",
2820 user_block_count);
Chao Yu9dc956b2018-06-27 18:05:54 +08002821 return 1;
2822 }
2823
Chao Yu7b63f722019-04-15 15:30:50 +08002824 valid_user_blocks = le64_to_cpu(ckpt->valid_block_count);
2825 if (valid_user_blocks > user_block_count) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002826 f2fs_err(sbi, "Wrong valid_user_blocks: %u, user_block_count: %u",
2827 valid_user_blocks, user_block_count);
Chao Yu7b63f722019-04-15 15:30:50 +08002828 return 1;
2829 }
2830
2831 valid_node_count = le32_to_cpu(ckpt->valid_node_count);
Chao Yu27cae0b2019-08-05 18:27:25 +08002832 avail_node_count = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;
Chao Yu7b63f722019-04-15 15:30:50 +08002833 if (valid_node_count > avail_node_count) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002834 f2fs_err(sbi, "Wrong valid_node_count: %u, avail_node_count: %u",
2835 valid_node_count, avail_node_count);
Chao Yu7b63f722019-04-15 15:30:50 +08002836 return 1;
2837 }
2838
Jin Qian15d30422017-05-15 10:45:08 -07002839 main_segs = le32_to_cpu(raw_super->segment_count_main);
2840 blocks_per_seg = sbi->blocks_per_seg;
2841
2842 for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
2843 if (le32_to_cpu(ckpt->cur_node_segno[i]) >= main_segs ||
2844 le16_to_cpu(ckpt->cur_node_blkoff[i]) >= blocks_per_seg)
2845 return 1;
Chao Yu042be0f2018-09-06 20:34:12 +08002846 for (j = i + 1; j < NR_CURSEG_NODE_TYPE; j++) {
2847 if (le32_to_cpu(ckpt->cur_node_segno[i]) ==
2848 le32_to_cpu(ckpt->cur_node_segno[j])) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002849 f2fs_err(sbi, "Node segment (%u, %u) has the same segno: %u",
2850 i, j,
2851 le32_to_cpu(ckpt->cur_node_segno[i]));
Chao Yu042be0f2018-09-06 20:34:12 +08002852 return 1;
2853 }
2854 }
Jin Qian15d30422017-05-15 10:45:08 -07002855 }
2856 for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) {
2857 if (le32_to_cpu(ckpt->cur_data_segno[i]) >= main_segs ||
2858 le16_to_cpu(ckpt->cur_data_blkoff[i]) >= blocks_per_seg)
2859 return 1;
Chao Yu042be0f2018-09-06 20:34:12 +08002860 for (j = i + 1; j < NR_CURSEG_DATA_TYPE; j++) {
2861 if (le32_to_cpu(ckpt->cur_data_segno[i]) ==
2862 le32_to_cpu(ckpt->cur_data_segno[j])) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002863 f2fs_err(sbi, "Data segment (%u, %u) has the same segno: %u",
2864 i, j,
2865 le32_to_cpu(ckpt->cur_data_segno[i]));
Chao Yu042be0f2018-09-06 20:34:12 +08002866 return 1;
2867 }
2868 }
2869 }
2870 for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
Surbhi Palande1166c1f2019-08-23 15:40:45 -07002871 for (j = 0; j < NR_CURSEG_DATA_TYPE; j++) {
Chao Yu042be0f2018-09-06 20:34:12 +08002872 if (le32_to_cpu(ckpt->cur_node_segno[i]) ==
2873 le32_to_cpu(ckpt->cur_data_segno[j])) {
Surbhi Palande1166c1f2019-08-23 15:40:45 -07002874 f2fs_err(sbi, "Node segment (%u) and Data segment (%u) has the same segno: %u",
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002875 i, j,
2876 le32_to_cpu(ckpt->cur_node_segno[i]));
Chao Yu042be0f2018-09-06 20:34:12 +08002877 return 1;
2878 }
2879 }
Jin Qian15d30422017-05-15 10:45:08 -07002880 }
2881
Chao Yuc77ec612018-06-23 11:25:19 +08002882 sit_bitmap_size = le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);
2883 nat_bitmap_size = le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);
Chao Yuc77ec612018-06-23 11:25:19 +08002884
2885 if (sit_bitmap_size != ((sit_segs / 2) << log_blocks_per_seg) / 8 ||
2886 nat_bitmap_size != ((nat_segs / 2) << log_blocks_per_seg) / 8) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002887 f2fs_err(sbi, "Wrong bitmap size: sit: %u, nat:%u",
2888 sit_bitmap_size, nat_bitmap_size);
Chao Yuc77ec612018-06-23 11:25:19 +08002889 return 1;
2890 }
2891
Chao Yue494c2f2018-08-01 19:16:11 +08002892 cp_pack_start_sum = __start_sum_addr(sbi);
2893 cp_payload = __cp_payload(sbi);
2894 if (cp_pack_start_sum < cp_payload + 1 ||
2895 cp_pack_start_sum > blocks_per_seg - 1 -
2896 NR_CURSEG_TYPE) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002897 f2fs_err(sbi, "Wrong cp_pack_start_sum: %u",
2898 cp_pack_start_sum);
Chao Yue494c2f2018-08-01 19:16:11 +08002899 return 1;
2900 }
2901
Chao Yu5dae2d32019-05-20 10:09:22 +08002902 if (__is_set_ckpt_flags(ckpt, CP_LARGE_NAT_BITMAP_FLAG) &&
2903 le32_to_cpu(ckpt->checksum_offset) != CP_MIN_CHKSUM_OFFSET) {
Chao Yu2d008832019-07-11 09:29:15 +08002904 f2fs_warn(sbi, "using deprecated layout of large_nat_bitmap, "
2905 "please run fsck v1.13.0 or higher to repair, chksum_offset: %u, "
2906 "fixed with patch: \"f2fs-tools: relocate chksum_offset for large_nat_bitmap feature\"",
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002907 le32_to_cpu(ckpt->checksum_offset));
Chao Yu5dae2d32019-05-20 10:09:22 +08002908 return 1;
2909 }
2910
Jaegeuk Kim1e968fd2014-08-11 16:49:25 -07002911 if (unlikely(f2fs_cp_error(sbi))) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08002912 f2fs_err(sbi, "A bug case: need to run fsck");
Jaegeuk Kim577e3492013-01-24 19:56:11 +09002913 return 1;
2914 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002915 return 0;
2916}
2917
2918static void init_sb_info(struct f2fs_sb_info *sbi)
2919{
2920 struct f2fs_super_block *raw_super = sbi->raw_super;
Yunlong Song089842d2018-10-24 16:09:42 +08002921 int i;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002922
2923 sbi->log_sectors_per_block =
2924 le32_to_cpu(raw_super->log_sectors_per_block);
2925 sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize);
2926 sbi->blocksize = 1 << sbi->log_blocksize;
2927 sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
2928 sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg;
2929 sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
2930 sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
2931 sbi->total_sections = le32_to_cpu(raw_super->section_count);
2932 sbi->total_node_count =
2933 (le32_to_cpu(raw_super->segment_count_nat) / 2)
2934 * sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK;
2935 sbi->root_ino_num = le32_to_cpu(raw_super->root_ino);
2936 sbi->node_ino_num = le32_to_cpu(raw_super->node_ino);
2937 sbi->meta_ino_num = le32_to_cpu(raw_super->meta_ino);
Jaegeuk Kim5ec4e492013-03-31 13:26:03 +09002938 sbi->cur_victim_sec = NULL_SECNO;
Chao Yue3080b02018-10-24 18:37:27 +08002939 sbi->next_victim_seg[BG_GC] = NULL_SEGNO;
2940 sbi->next_victim_seg[FG_GC] = NULL_SEGNO;
Jaegeuk Kimb1c57c12014-01-08 13:45:08 +09002941 sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH;
Chao Yue3080b02018-10-24 18:37:27 +08002942 sbi->migration_granularity = sbi->segs_per_sec;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002943
Jaegeuk Kimab9fa662014-02-27 20:09:05 +09002944 sbi->dir_level = DEF_DIR_LEVEL;
Jaegeuk Kim6beceb52016-01-08 15:51:50 -08002945 sbi->interval_time[CP_TIME] = DEF_CP_INTERVAL;
Jaegeuk Kimd0239e12016-01-08 16:57:48 -08002946 sbi->interval_time[REQ_TIME] = DEF_IDLE_INTERVAL;
Sahitya Tummalaa7d10cf2018-09-19 14:18:47 +05302947 sbi->interval_time[DISCARD_TIME] = DEF_IDLE_INTERVAL;
2948 sbi->interval_time[GC_TIME] = DEF_IDLE_INTERVAL;
Daniel Rosenberg43549942018-08-20 19:21:43 -07002949 sbi->interval_time[DISABLE_TIME] = DEF_DISABLE_INTERVAL;
Jaegeuk Kim03f2c022019-01-14 10:42:11 -08002950 sbi->interval_time[UMOUNT_DISCARD_TIMEOUT] =
2951 DEF_UMOUNT_DISCARD_TIMEOUT;
Chao Yucaf00472015-01-28 17:48:42 +08002952 clear_sbi_flag(sbi, SBI_NEED_FSCK);
Jaegeuk Kim2658e502015-06-19 12:01:21 -07002953
Jaegeuk Kim35782b22016-10-20 19:09:57 -07002954 for (i = 0; i < NR_COUNT_TYPE; i++)
2955 atomic_set(&sbi->nr_pages[i], 0);
2956
Chao Yuc29fd0c2018-06-04 23:20:36 +08002957 for (i = 0; i < META; i++)
2958 atomic_set(&sbi->wb_sync_req[i], 0);
Jaegeuk Kim687de7f2017-03-28 18:07:38 -07002959
Jaegeuk Kim2658e502015-06-19 12:01:21 -07002960 INIT_LIST_HEAD(&sbi->s_list);
2961 mutex_init(&sbi->umount_mutex);
Chao Yu107a8052018-05-26 09:00:13 +08002962 init_rwsem(&sbi->io_order_lock);
Chao Yuaaec2b12016-09-20 11:04:18 +08002963 spin_lock_init(&sbi->cp_lock);
Chao Yu1228b482017-09-29 13:59:39 +08002964
2965 sbi->dirty_device = 0;
2966 spin_lock_init(&sbi->dev_lock);
Chao Yud0d3f1b2018-02-11 22:53:20 +08002967
Chao Yu846ae672018-02-26 22:04:13 +08002968 init_rwsem(&sbi->sb_lock);
Jaegeuk Kimf5a53ed2019-10-18 10:06:40 -07002969 init_rwsem(&sbi->pin_sem);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002970}
2971
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07002972static int init_percpu_info(struct f2fs_sb_info *sbi)
2973{
Jaegeuk Kim35782b22016-10-20 19:09:57 -07002974 int err;
Jaegeuk Kim41382ec2016-05-16 11:06:50 -07002975
Jaegeuk Kim513c5f32016-05-16 11:42:32 -07002976 err = percpu_counter_init(&sbi->alloc_valid_block_count, 0, GFP_KERNEL);
2977 if (err)
2978 return err;
2979
Chao Yu4a70e252018-09-05 14:54:02 +08002980 err = percpu_counter_init(&sbi->total_valid_inode_count, 0,
Jaegeuk Kim41382ec2016-05-16 11:06:50 -07002981 GFP_KERNEL);
Chao Yu4a70e252018-09-05 14:54:02 +08002982 if (err)
2983 percpu_counter_destroy(&sbi->alloc_valid_block_count);
2984
2985 return err;
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07002986}
2987
Damien Le Moal178053e2016-10-28 17:45:05 +09002988#ifdef CONFIG_BLK_DEV_ZONED
Christoph Hellwigd4100352019-11-11 11:39:30 +09002989static int f2fs_report_zone_cb(struct blk_zone *zone, unsigned int idx,
2990 void *data)
2991{
2992 struct f2fs_dev_info *dev = data;
2993
2994 if (zone->type != BLK_ZONE_TYPE_CONVENTIONAL)
2995 set_bit(idx, dev->blkz_seq);
2996 return 0;
2997}
2998
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002999static int init_blkz_info(struct f2fs_sb_info *sbi, int devi)
Damien Le Moal178053e2016-10-28 17:45:05 +09003000{
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003001 struct block_device *bdev = FDEV(devi).bdev;
Damien Le Moal178053e2016-10-28 17:45:05 +09003002 sector_t nr_sectors = bdev->bd_part->nr_sects;
Christoph Hellwigd4100352019-11-11 11:39:30 +09003003 int ret;
Damien Le Moal178053e2016-10-28 17:45:05 +09003004
Chao Yu7beb01f2018-10-24 18:34:26 +08003005 if (!f2fs_sb_has_blkzoned(sbi))
Damien Le Moal178053e2016-10-28 17:45:05 +09003006 return 0;
3007
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003008 if (sbi->blocks_per_blkz && sbi->blocks_per_blkz !=
Damien Le Moalf99e8642017-01-12 07:58:32 -07003009 SECTOR_TO_BLOCK(bdev_zone_sectors(bdev)))
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003010 return -EINVAL;
Damien Le Moalf99e8642017-01-12 07:58:32 -07003011 sbi->blocks_per_blkz = SECTOR_TO_BLOCK(bdev_zone_sectors(bdev));
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003012 if (sbi->log_blocks_per_blkz && sbi->log_blocks_per_blkz !=
3013 __ilog2_u32(sbi->blocks_per_blkz))
3014 return -EINVAL;
Damien Le Moal178053e2016-10-28 17:45:05 +09003015 sbi->log_blocks_per_blkz = __ilog2_u32(sbi->blocks_per_blkz);
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003016 FDEV(devi).nr_blkz = SECTOR_TO_BLOCK(nr_sectors) >>
3017 sbi->log_blocks_per_blkz;
Damien Le Moalf99e8642017-01-12 07:58:32 -07003018 if (nr_sectors & (bdev_zone_sectors(bdev) - 1))
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003019 FDEV(devi).nr_blkz++;
Damien Le Moal178053e2016-10-28 17:45:05 +09003020
Damien Le Moal95175da2019-03-16 09:13:07 +09003021 FDEV(devi).blkz_seq = f2fs_kzalloc(sbi,
3022 BITS_TO_LONGS(FDEV(devi).nr_blkz)
3023 * sizeof(unsigned long),
3024 GFP_KERNEL);
3025 if (!FDEV(devi).blkz_seq)
Damien Le Moal178053e2016-10-28 17:45:05 +09003026 return -ENOMEM;
3027
Damien Le Moal178053e2016-10-28 17:45:05 +09003028 /* Get block zones type */
Christoph Hellwigd4100352019-11-11 11:39:30 +09003029 ret = blkdev_report_zones(bdev, 0, BLK_ALL_ZONES, f2fs_report_zone_cb,
3030 &FDEV(devi));
3031 if (ret < 0)
3032 return ret;
Damien Le Moal178053e2016-10-28 17:45:05 +09003033
Christoph Hellwigd4100352019-11-11 11:39:30 +09003034 return 0;
Damien Le Moal178053e2016-10-28 17:45:05 +09003035}
3036#endif
3037
Gu Zheng9076a752013-10-14 18:47:11 +08003038/*
3039 * Read f2fs raw super block.
Shawn Lin2b39e902016-02-17 08:59:01 +08003040 * Because we have two copies of super block, so read both of them
3041 * to get the first valid one. If any one of them is broken, we pass
3042 * them recovery flag back to the caller.
Gu Zheng9076a752013-10-14 18:47:11 +08003043 */
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07003044static int read_raw_super_block(struct f2fs_sb_info *sbi,
Gu Zheng9076a752013-10-14 18:47:11 +08003045 struct f2fs_super_block **raw_super,
Chao Yue8240f62015-12-15 17:19:26 +08003046 int *valid_super_block, int *recovery)
majianpeng14d7e9d2013-02-01 19:07:03 +08003047{
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07003048 struct super_block *sb = sbi->sb;
Shawn Lin2b39e902016-02-17 08:59:01 +08003049 int block;
Chao Yue8240f62015-12-15 17:19:26 +08003050 struct buffer_head *bh;
Jaegeuk Kimfd694732016-03-20 15:33:20 -07003051 struct f2fs_super_block *super;
hujianyangda554e42015-05-21 14:42:53 +08003052 int err = 0;
majianpeng14d7e9d2013-02-01 19:07:03 +08003053
Yunlei Heb39f0de2015-12-15 17:17:20 +08003054 super = kzalloc(sizeof(struct f2fs_super_block), GFP_KERNEL);
3055 if (!super)
3056 return -ENOMEM;
Shawn Lin2b39e902016-02-17 08:59:01 +08003057
3058 for (block = 0; block < 2; block++) {
3059 bh = sb_bread(sb, block);
3060 if (!bh) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003061 f2fs_err(sbi, "Unable to read %dth superblock",
3062 block + 1);
Shawn Lin2b39e902016-02-17 08:59:01 +08003063 err = -EIO;
Chengguang Xu via Linux-f2fs-develed3520422019-09-27 09:35:48 +08003064 *recovery = 1;
Shawn Lin2b39e902016-02-17 08:59:01 +08003065 continue;
3066 }
majianpeng14d7e9d2013-02-01 19:07:03 +08003067
Shawn Lin2b39e902016-02-17 08:59:01 +08003068 /* sanity checking of raw super */
Icenowy Zheng38fb6d02019-07-25 11:08:52 +08003069 err = sanity_check_raw_super(sbi, bh);
3070 if (err) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003071 f2fs_err(sbi, "Can't find valid F2FS filesystem in %dth superblock",
3072 block + 1);
Shawn Lin2b39e902016-02-17 08:59:01 +08003073 brelse(bh);
Chengguang Xu via Linux-f2fs-develed3520422019-09-27 09:35:48 +08003074 *recovery = 1;
Shawn Lin2b39e902016-02-17 08:59:01 +08003075 continue;
3076 }
3077
3078 if (!*raw_super) {
Jaegeuk Kimfd694732016-03-20 15:33:20 -07003079 memcpy(super, bh->b_data + F2FS_SUPER_OFFSET,
3080 sizeof(*super));
Shawn Lin2b39e902016-02-17 08:59:01 +08003081 *valid_super_block = block;
3082 *raw_super = super;
3083 }
Chao Yue8240f62015-12-15 17:19:26 +08003084 brelse(bh);
Shawn Lin2b39e902016-02-17 08:59:01 +08003085 }
3086
hujianyangda554e42015-05-21 14:42:53 +08003087 /* No valid superblock */
Shawn Lin2b39e902016-02-17 08:59:01 +08003088 if (!*raw_super)
Jaegeuk Kim52225952018-12-13 18:38:33 -08003089 kvfree(super);
Shawn Lin2b39e902016-02-17 08:59:01 +08003090 else
3091 err = 0;
hujianyangda554e42015-05-21 14:42:53 +08003092
Shawn Lin2b39e902016-02-17 08:59:01 +08003093 return err;
majianpeng14d7e9d2013-02-01 19:07:03 +08003094}
3095
Jaegeuk Kimfd694732016-03-20 15:33:20 -07003096int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover)
Jaegeuk Kim26d815ad2015-04-20 18:49:51 -07003097{
Jaegeuk Kim5d909cd2015-12-07 10:16:58 -08003098 struct buffer_head *bh;
Junling Zhengd440c522018-09-28 20:25:56 +08003099 __u32 crc = 0;
Jaegeuk Kim26d815ad2015-04-20 18:49:51 -07003100 int err;
3101
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07003102 if ((recover && f2fs_readonly(sbi->sb)) ||
3103 bdev_read_only(sbi->sb->s_bdev)) {
3104 set_sbi_flag(sbi, SBI_NEED_SB_WRITE);
Jaegeuk Kimf2353d72016-03-23 10:42:01 -07003105 return -EROFS;
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07003106 }
Jaegeuk Kimf2353d72016-03-23 10:42:01 -07003107
Junling Zhengd440c522018-09-28 20:25:56 +08003108 /* we should update superblock crc here */
Chao Yu7beb01f2018-10-24 18:34:26 +08003109 if (!recover && f2fs_sb_has_sb_chksum(sbi)) {
Junling Zhengd440c522018-09-28 20:25:56 +08003110 crc = f2fs_crc32(sbi, F2FS_RAW_SUPER(sbi),
3111 offsetof(struct f2fs_super_block, crc));
3112 F2FS_RAW_SUPER(sbi)->crc = cpu_to_le32(crc);
3113 }
3114
Jaegeuk Kimfd694732016-03-20 15:33:20 -07003115 /* write back-up superblock first */
Sheng Yong0964fc12018-01-29 19:13:15 +08003116 bh = sb_bread(sbi->sb, sbi->valid_super_block ? 0 : 1);
Jaegeuk Kim5d909cd2015-12-07 10:16:58 -08003117 if (!bh)
3118 return -EIO;
Jaegeuk Kimfd694732016-03-20 15:33:20 -07003119 err = __f2fs_commit_super(bh, F2FS_RAW_SUPER(sbi));
Jaegeuk Kim5d909cd2015-12-07 10:16:58 -08003120 brelse(bh);
Chao Yuc5bda1c2015-06-08 13:28:03 +08003121
3122 /* if we are in recovery path, skip writing valid superblock */
3123 if (recover || err)
Jaegeuk Kim5d909cd2015-12-07 10:16:58 -08003124 return err;
Jaegeuk Kim26d815ad2015-04-20 18:49:51 -07003125
Chao Yue8240f62015-12-15 17:19:26 +08003126 /* write current valid superblock */
Sheng Yong0964fc12018-01-29 19:13:15 +08003127 bh = sb_bread(sbi->sb, sbi->valid_super_block);
Jaegeuk Kimfd694732016-03-20 15:33:20 -07003128 if (!bh)
3129 return -EIO;
3130 err = __f2fs_commit_super(bh, F2FS_RAW_SUPER(sbi));
3131 brelse(bh);
3132 return err;
Jaegeuk Kim26d815ad2015-04-20 18:49:51 -07003133}
3134
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003135static int f2fs_scan_devices(struct f2fs_sb_info *sbi)
3136{
3137 struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
Masato Suzuki7bb3a372017-02-27 20:52:49 +09003138 unsigned int max_devices = MAX_DEVICES;
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003139 int i;
3140
Masato Suzuki7bb3a372017-02-27 20:52:49 +09003141 /* Initialize single device information */
3142 if (!RDEV(0).path[0]) {
3143 if (!bdev_is_zoned(sbi->sb->s_bdev))
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003144 return 0;
Masato Suzuki7bb3a372017-02-27 20:52:49 +09003145 max_devices = 1;
3146 }
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003147
Masato Suzuki7bb3a372017-02-27 20:52:49 +09003148 /*
3149 * Initialize multiple devices information, or single
3150 * zoned block device information.
3151 */
Kees Cook026f0502018-06-12 14:28:23 -07003152 sbi->devs = f2fs_kzalloc(sbi,
3153 array_size(max_devices,
3154 sizeof(struct f2fs_dev_info)),
3155 GFP_KERNEL);
Masato Suzuki7bb3a372017-02-27 20:52:49 +09003156 if (!sbi->devs)
3157 return -ENOMEM;
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003158
Masato Suzuki7bb3a372017-02-27 20:52:49 +09003159 for (i = 0; i < max_devices; i++) {
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003160
Masato Suzuki7bb3a372017-02-27 20:52:49 +09003161 if (i > 0 && !RDEV(i).path[0])
3162 break;
3163
3164 if (max_devices == 1) {
3165 /* Single zoned block device mount */
3166 FDEV(0).bdev =
3167 blkdev_get_by_dev(sbi->sb->s_bdev->bd_dev,
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003168 sbi->sb->s_mode, sbi->sb->s_type);
Masato Suzuki7bb3a372017-02-27 20:52:49 +09003169 } else {
3170 /* Multi-device mount */
3171 memcpy(FDEV(i).path, RDEV(i).path, MAX_PATH_LEN);
3172 FDEV(i).total_segments =
3173 le32_to_cpu(RDEV(i).total_segments);
3174 if (i == 0) {
3175 FDEV(i).start_blk = 0;
3176 FDEV(i).end_blk = FDEV(i).start_blk +
3177 (FDEV(i).total_segments <<
3178 sbi->log_blocks_per_seg) - 1 +
3179 le32_to_cpu(raw_super->segment0_blkaddr);
3180 } else {
3181 FDEV(i).start_blk = FDEV(i - 1).end_blk + 1;
3182 FDEV(i).end_blk = FDEV(i).start_blk +
3183 (FDEV(i).total_segments <<
3184 sbi->log_blocks_per_seg) - 1;
3185 }
3186 FDEV(i).bdev = blkdev_get_by_path(FDEV(i).path,
3187 sbi->sb->s_mode, sbi->sb->s_type);
3188 }
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003189 if (IS_ERR(FDEV(i).bdev))
3190 return PTR_ERR(FDEV(i).bdev);
3191
3192 /* to release errored devices */
3193 sbi->s_ndevs = i + 1;
3194
3195#ifdef CONFIG_BLK_DEV_ZONED
3196 if (bdev_zoned_model(FDEV(i).bdev) == BLK_ZONED_HM &&
Chao Yu7beb01f2018-10-24 18:34:26 +08003197 !f2fs_sb_has_blkzoned(sbi)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003198 f2fs_err(sbi, "Zoned block device feature not enabled\n");
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003199 return -EINVAL;
3200 }
3201 if (bdev_zoned_model(FDEV(i).bdev) != BLK_ZONED_NONE) {
3202 if (init_blkz_info(sbi, i)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003203 f2fs_err(sbi, "Failed to initialize F2FS blkzone information");
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003204 return -EINVAL;
3205 }
Masato Suzuki7bb3a372017-02-27 20:52:49 +09003206 if (max_devices == 1)
3207 break;
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003208 f2fs_info(sbi, "Mount Device [%2d]: %20s, %8u, %8x - %8x (zone: %s)",
3209 i, FDEV(i).path,
3210 FDEV(i).total_segments,
3211 FDEV(i).start_blk, FDEV(i).end_blk,
3212 bdev_zoned_model(FDEV(i).bdev) == BLK_ZONED_HA ?
3213 "Host-aware" : "Host-managed");
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003214 continue;
3215 }
3216#endif
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003217 f2fs_info(sbi, "Mount Device [%2d]: %20s, %8u, %8x - %8x",
3218 i, FDEV(i).path,
3219 FDEV(i).total_segments,
3220 FDEV(i).start_blk, FDEV(i).end_blk);
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003221 }
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003222 f2fs_info(sbi,
3223 "IO Block Size: %8d KB", F2FS_IO_SIZE_KB(sbi));
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003224 return 0;
3225}
3226
Daniel Rosenberg5aba5432019-07-23 16:05:28 -07003227static int f2fs_setup_casefold(struct f2fs_sb_info *sbi)
3228{
3229#ifdef CONFIG_UNICODE
3230 if (f2fs_sb_has_casefold(sbi) && !sbi->s_encoding) {
3231 const struct f2fs_sb_encodings *encoding_info;
3232 struct unicode_map *encoding;
3233 __u16 encoding_flags;
3234
3235 if (f2fs_sb_has_encrypt(sbi)) {
3236 f2fs_err(sbi,
3237 "Can't mount with encoding and encryption");
3238 return -EINVAL;
3239 }
3240
3241 if (f2fs_sb_read_encoding(sbi->raw_super, &encoding_info,
3242 &encoding_flags)) {
3243 f2fs_err(sbi,
3244 "Encoding requested by superblock is unknown");
3245 return -EINVAL;
3246 }
3247
3248 encoding = utf8_load(encoding_info->version);
3249 if (IS_ERR(encoding)) {
3250 f2fs_err(sbi,
3251 "can't mount with superblock charset: %s-%s "
3252 "not supported by the kernel. flags: 0x%x.",
3253 encoding_info->name, encoding_info->version,
3254 encoding_flags);
3255 return PTR_ERR(encoding);
3256 }
3257 f2fs_info(sbi, "Using encoding defined by superblock: "
3258 "%s-%s with flags 0x%hx", encoding_info->name,
3259 encoding_info->version?:"\b", encoding_flags);
3260
3261 sbi->s_encoding = encoding;
3262 sbi->s_encoding_flags = encoding_flags;
Daniel Rosenberg2c2eb7a2019-07-23 16:05:29 -07003263 sbi->sb->s_d_op = &f2fs_dentry_ops;
Daniel Rosenberg5aba5432019-07-23 16:05:28 -07003264 }
3265#else
3266 if (f2fs_sb_has_casefold(sbi)) {
3267 f2fs_err(sbi, "Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");
3268 return -EINVAL;
3269 }
3270#endif
3271 return 0;
3272}
3273
Jaegeuk Kim84b89e52018-02-22 14:09:30 -08003274static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
3275{
3276 struct f2fs_sm_info *sm_i = SM_I(sbi);
3277
3278 /* adjust parameters according to the volume size */
3279 if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
Chao Yu63189b72018-03-08 14:22:56 +08003280 F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
Jaegeuk Kim84b89e52018-02-22 14:09:30 -08003281 sm_i->dcc_info->discard_granularity = 1;
3282 sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
3283 }
Chao Yu4cac90d2018-06-11 18:02:01 +08003284
3285 sbi->readdir_ra = 1;
Jaegeuk Kim84b89e52018-02-22 14:09:30 -08003286}
3287
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003288static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
3289{
3290 struct f2fs_sb_info *sbi;
hujianyangda554e42015-05-21 14:42:53 +08003291 struct f2fs_super_block *raw_super;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003292 struct inode *root;
Sheng Yong99e3e852016-05-11 17:08:14 +08003293 int err;
Chao Yuaa2c8c42019-02-19 16:23:53 +08003294 bool skip_recovery = false, need_fsck = false;
Jaegeuk Kimdabc4a52015-01-23 17:41:39 -08003295 char *options = NULL;
Chao Yue8240f62015-12-15 17:19:26 +08003296 int recovery, i, valid_super_block;
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08003297 struct curseg_info *seg_i;
Chao Yuaa2c8c42019-02-19 16:23:53 +08003298 int retry_cnt = 1;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003299
Jaegeuk Kimed2e6212014-08-08 15:37:41 -07003300try_onemore:
hujianyangda554e42015-05-21 14:42:53 +08003301 err = -EINVAL;
3302 raw_super = NULL;
Chao Yue8240f62015-12-15 17:19:26 +08003303 valid_super_block = -1;
hujianyangda554e42015-05-21 14:42:53 +08003304 recovery = 0;
3305
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003306 /* allocate memory for f2fs-specific super block info */
3307 sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
3308 if (!sbi)
3309 return -ENOMEM;
3310
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07003311 sbi->sb = sb;
3312
Keith Mok43b65732016-03-02 12:04:24 -08003313 /* Load the checksum driver */
3314 sbi->s_chksum_driver = crypto_alloc_shash("crc32", 0, 0);
3315 if (IS_ERR(sbi->s_chksum_driver)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003316 f2fs_err(sbi, "Cannot load crc32 driver.");
Keith Mok43b65732016-03-02 12:04:24 -08003317 err = PTR_ERR(sbi->s_chksum_driver);
3318 sbi->s_chksum_driver = NULL;
3319 goto free_sbi;
3320 }
3321
Namjae Jeonff9234a2013-01-12 14:41:13 +09003322 /* set a block size */
Jaegeuk Kim6bacf522013-12-06 15:00:58 +09003323 if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003324 f2fs_err(sbi, "unable to set blocksize");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003325 goto free_sbi;
Namjae Jeona07ef782012-12-30 14:52:05 +09003326 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003327
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07003328 err = read_raw_super_block(sbi, &raw_super, &valid_super_block,
Chao Yue8240f62015-12-15 17:19:26 +08003329 &recovery);
Gu Zheng9076a752013-10-14 18:47:11 +08003330 if (err)
3331 goto free_sbi;
3332
Gu Zheng5fb08372013-06-07 14:16:53 +08003333 sb->s_fs_info = sbi;
Jaegeuk Kim52763a42016-06-13 09:47:48 -07003334 sbi->raw_super = raw_super;
3335
Chao Yu704956e2017-07-31 20:19:09 +08003336 /* precompute checksum seed for metadata */
Chao Yu7beb01f2018-10-24 18:34:26 +08003337 if (f2fs_sb_has_inode_chksum(sbi))
Chao Yu704956e2017-07-31 20:19:09 +08003338 sbi->s_chksum_seed = f2fs_chksum(sbi, ~0, raw_super->uuid,
3339 sizeof(raw_super->uuid));
3340
Damien Le Moald1b959c2016-10-28 17:45:01 +09003341 /*
3342 * The BLKZONED feature indicates that the drive was formatted with
3343 * zone alignment optimization. This is optional for host-aware
3344 * devices, but mandatory for host-managed zoned block devices.
3345 */
3346#ifndef CONFIG_BLK_DEV_ZONED
Chao Yu7beb01f2018-10-24 18:34:26 +08003347 if (f2fs_sb_has_blkzoned(sbi)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003348 f2fs_err(sbi, "Zoned block device support is not enabled");
Chao Yu1727f312017-06-12 09:44:27 +08003349 err = -EOPNOTSUPP;
Damien Le Moald1b959c2016-10-28 17:45:01 +09003350 goto free_sb_buf;
3351 }
Damien Le Moald1b959c2016-10-28 17:45:01 +09003352#endif
Yunlei He498c5e92015-05-07 18:11:37 +08003353 default_options(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003354 /* parse mount options */
Jaegeuk Kimdabc4a52015-01-23 17:41:39 -08003355 options = kstrdup((const char *)data, GFP_KERNEL);
3356 if (data && !options) {
3357 err = -ENOMEM;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003358 goto free_sb_buf;
Jaegeuk Kimdabc4a52015-01-23 17:41:39 -08003359 }
3360
3361 err = parse_options(sb, options);
3362 if (err)
3363 goto free_options;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003364
Chao Yue0afc4d2015-12-31 14:35:37 +08003365 sbi->max_file_blocks = max_file_blocks();
3366 sb->s_maxbytes = sbi->max_file_blocks <<
3367 le32_to_cpu(raw_super->log_blocksize);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003368 sb->s_max_links = F2FS_LINK_MAX;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003369
Daniel Rosenberg5aba5432019-07-23 16:05:28 -07003370 err = f2fs_setup_casefold(sbi);
3371 if (err)
3372 goto free_options;
3373
Chao Yu0abd6752017-07-09 00:13:07 +08003374#ifdef CONFIG_QUOTA
3375 sb->dq_op = &f2fs_quota_operations;
Jaegeuk Kimbc88ac92019-05-20 16:17:56 -07003376 sb->s_qcop = &f2fs_quotactl_ops;
Chao Yu5c571322017-07-26 00:01:41 +08003377 sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;
Chao Yu292c196a2017-11-16 16:59:14 +08003378
Chao Yu7beb01f2018-10-24 18:34:26 +08003379 if (f2fs_sb_has_quota_ino(sbi)) {
Chao Yu292c196a2017-11-16 16:59:14 +08003380 for (i = 0; i < MAXQUOTAS; i++) {
3381 if (f2fs_qf_ino(sbi->sb, i))
3382 sbi->nquota_files++;
3383 }
3384 }
Chao Yu0abd6752017-07-09 00:13:07 +08003385#endif
3386
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003387 sb->s_op = &f2fs_sops;
Chandan Rajendra643fa962018-12-12 15:20:12 +05303388#ifdef CONFIG_FS_ENCRYPTION
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07003389 sb->s_cop = &f2fs_cryptops;
Eric Biggersffcc41822017-10-09 12:15:38 -07003390#endif
Eric Biggers95ae2512019-07-22 09:26:24 -07003391#ifdef CONFIG_FS_VERITY
3392 sb->s_vop = &f2fs_verityops;
3393#endif
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003394 sb->s_xattr = f2fs_xattr_handlers;
3395 sb->s_export_op = &f2fs_export_ops;
3396 sb->s_magic = F2FS_SUPER_MAGIC;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003397 sb->s_time_gran = 1;
Linus Torvalds1751e8a2017-11-27 13:05:09 -08003398 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
3399 (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
Christoph Hellwig85787092017-05-10 15:06:33 +02003400 memcpy(&sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid));
Yufen Yu578c6472018-01-09 19:33:39 +08003401 sb->s_iflags |= SB_I_CGROUPWB;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003402
3403 /* init f2fs-specific super block info */
Chao Yue8240f62015-12-15 17:19:26 +08003404 sbi->valid_super_block = valid_super_block;
Chao Yufb24fea2020-01-14 19:36:50 +08003405 init_rwsem(&sbi->gc_lock);
Jaegeuk Kim853137c2018-08-09 17:53:34 -07003406 mutex_init(&sbi->writepages);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003407 mutex_init(&sbi->cp_mutex);
Qiuyang Sun04f0b2e2019-06-05 11:33:25 +08003408 mutex_init(&sbi->resize_mutex);
Chao Yub3582c62014-07-03 18:58:39 +08003409 init_rwsem(&sbi->node_write);
Yunlei He59c90812017-03-13 20:22:18 +08003410 init_rwsem(&sbi->node_change);
Jaegeuk Kim315df832015-08-11 12:45:39 -07003411
3412 /* disallow all the data/node/meta page writes */
3413 set_sbi_flag(sbi, SBI_POR_DOING);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003414 spin_lock_init(&sbi->stat_lock);
Jaegeuk Kim971767c2013-11-18 17:16:17 +09003415
Chao Yub0af6d42017-08-02 23:21:48 +08003416 /* init iostat info */
3417 spin_lock_init(&sbi->iostat_lock);
3418 sbi->iostat_enable = false;
3419
Jaegeuk Kim458e6192013-12-11 13:54:01 +09003420 for (i = 0; i < NR_PAGE_TYPE; i++) {
Jaegeuk Kima912b542017-05-10 11:18:25 -07003421 int n = (i == META) ? 1: NR_TEMP_TYPE;
3422 int j;
3423
Kees Cookc8606592018-06-12 14:28:16 -07003424 sbi->write_io[i] =
3425 f2fs_kmalloc(sbi,
3426 array_size(n,
3427 sizeof(struct f2fs_bio_info)),
3428 GFP_KERNEL);
Christophe JAILLETb63def92017-06-11 09:21:11 +02003429 if (!sbi->write_io[i]) {
3430 err = -ENOMEM;
Chao Yu0b2103e82018-09-05 14:54:01 +08003431 goto free_bio_info;
Christophe JAILLETb63def92017-06-11 09:21:11 +02003432 }
Jaegeuk Kima912b542017-05-10 11:18:25 -07003433
3434 for (j = HOT; j < n; j++) {
3435 init_rwsem(&sbi->write_io[i][j].io_rwsem);
3436 sbi->write_io[i][j].sbi = sbi;
3437 sbi->write_io[i][j].bio = NULL;
Chao Yufb830fc2017-05-19 23:37:01 +08003438 spin_lock_init(&sbi->write_io[i][j].io_lock);
3439 INIT_LIST_HEAD(&sbi->write_io[i][j].io_list);
Chao Yu0b20fce2019-09-30 18:53:25 +08003440 INIT_LIST_HEAD(&sbi->write_io[i][j].bio_list);
3441 init_rwsem(&sbi->write_io[i][j].bio_list_lock);
Jaegeuk Kima912b542017-05-10 11:18:25 -07003442 }
Jaegeuk Kim458e6192013-12-11 13:54:01 +09003443 }
Jaegeuk Kim971767c2013-11-18 17:16:17 +09003444
Jaegeuk Kimb873b792016-08-04 11:38:25 -07003445 init_rwsem(&sbi->cp_rwsem);
Jaegeuk Kimdb6ec532019-05-29 10:58:45 -07003446 init_rwsem(&sbi->quota_sem);
Changman Leefb51b5e2013-11-07 12:48:25 +09003447 init_waitqueue_head(&sbi->cp_wait);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003448 init_sb_info(sbi);
3449
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07003450 err = init_percpu_info(sbi);
3451 if (err)
Chao Yud7997e62018-01-17 16:31:35 +08003452 goto free_bio_info;
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07003453
Chao Yuc72db712019-07-12 16:55:42 +08003454 if (F2FS_IO_ALIGNED(sbi)) {
Jaegeuk Kim0a595eb2016-12-14 10:12:56 -08003455 sbi->write_io_dummy =
Chao Yua3ebfe42017-02-27 18:43:13 +08003456 mempool_create_page_pool(2 * (F2FS_IO_SIZE(sbi) - 1), 0);
Chao Yu1727f312017-06-12 09:44:27 +08003457 if (!sbi->write_io_dummy) {
3458 err = -ENOMEM;
Chao Yud7997e62018-01-17 16:31:35 +08003459 goto free_percpu;
Chao Yu1727f312017-06-12 09:44:27 +08003460 }
Jaegeuk Kim0a595eb2016-12-14 10:12:56 -08003461 }
3462
Chao Yua9991502020-02-25 18:17:10 +08003463 /* init per sbi slab cache */
3464 err = f2fs_init_xattr_caches(sbi);
3465 if (err)
3466 goto free_io_dummy;
3467
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003468 /* get an inode for meta space */
3469 sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi));
3470 if (IS_ERR(sbi->meta_inode)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003471 f2fs_err(sbi, "Failed to read F2FS meta data inode");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003472 err = PTR_ERR(sbi->meta_inode);
Chao Yua9991502020-02-25 18:17:10 +08003473 goto free_xattr_cache;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003474 }
3475
Chao Yu4d57b862018-05-30 00:20:41 +08003476 err = f2fs_get_valid_checkpoint(sbi);
Namjae Jeona07ef782012-12-30 14:52:05 +09003477 if (err) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003478 f2fs_err(sbi, "Failed to get valid F2FS checkpoint");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003479 goto free_meta_inode;
Namjae Jeona07ef782012-12-30 14:52:05 +09003480 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003481
Chao Yuaf033b22018-09-20 20:05:00 +08003482 if (__is_set_ckpt_flags(F2FS_CKPT(sbi), CP_QUOTA_NEED_FSCK_FLAG))
3483 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
Jaegeuk Kimdb610a62019-01-24 17:48:38 -08003484 if (__is_set_ckpt_flags(F2FS_CKPT(sbi), CP_DISABLED_QUICK_FLAG)) {
3485 set_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);
3486 sbi->interval_time[DISABLE_TIME] = DEF_DISABLE_QUICK_INTERVAL;
3487 }
Chao Yuaf033b22018-09-20 20:05:00 +08003488
Qiuyang Sun04f0b2e2019-06-05 11:33:25 +08003489 if (__is_set_ckpt_flags(F2FS_CKPT(sbi), CP_FSCK_FLAG))
3490 set_sbi_flag(sbi, SBI_NEED_FSCK);
3491
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003492 /* Initialize device list */
3493 err = f2fs_scan_devices(sbi);
3494 if (err) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003495 f2fs_err(sbi, "Failed to find devices");
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003496 goto free_devices;
3497 }
3498
Chao Yu4c8ff702019-11-01 18:07:14 +08003499 err = f2fs_init_post_read_wq(sbi);
3500 if (err) {
3501 f2fs_err(sbi, "Failed to initialize post read workqueue");
3502 goto free_devices;
3503 }
3504
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003505 sbi->total_valid_node_count =
3506 le32_to_cpu(sbi->ckpt->valid_node_count);
Jaegeuk Kim513c5f32016-05-16 11:42:32 -07003507 percpu_counter_set(&sbi->total_valid_inode_count,
3508 le32_to_cpu(sbi->ckpt->valid_inode_count));
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003509 sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count);
3510 sbi->total_valid_block_count =
3511 le64_to_cpu(sbi->ckpt->valid_block_count);
3512 sbi->last_valid_block_count = sbi->total_valid_block_count;
Chao Yudaeb4332017-06-26 16:24:41 +08003513 sbi->reserved_blocks = 0;
Yunlong Song80d42142017-10-27 20:45:05 +08003514 sbi->current_reserved_blocks = 0;
Jaegeuk Kim7e65be42017-12-27 15:05:52 -08003515 limit_reserve_root(sbi);
Jaegeuk Kim41382ec2016-05-16 11:06:50 -07003516
Chao Yuc227f912015-12-16 13:09:20 +08003517 for (i = 0; i < NR_INODE_TYPE; i++) {
3518 INIT_LIST_HEAD(&sbi->inode_list[i]);
3519 spin_lock_init(&sbi->inode_lock[i]);
3520 }
Chao Yu040d2bb2019-05-20 17:36:59 +08003521 mutex_init(&sbi->flush_lock);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003522
Chao Yu4d57b862018-05-30 00:20:41 +08003523 f2fs_init_extent_cache_info(sbi);
Chao Yu1dcc3362015-02-05 17:57:31 +08003524
Chao Yu4d57b862018-05-30 00:20:41 +08003525 f2fs_init_ino_entry_info(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003526
Chao Yu50fa53e2018-08-02 23:03:19 +08003527 f2fs_init_fsync_node_info(sbi);
3528
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003529 /* setup f2fs internal modules */
Chao Yu4d57b862018-05-30 00:20:41 +08003530 err = f2fs_build_segment_manager(sbi);
Namjae Jeona07ef782012-12-30 14:52:05 +09003531 if (err) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003532 f2fs_err(sbi, "Failed to initialize F2FS segment manager (%d)",
3533 err);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003534 goto free_sm;
Namjae Jeona07ef782012-12-30 14:52:05 +09003535 }
Chao Yu4d57b862018-05-30 00:20:41 +08003536 err = f2fs_build_node_manager(sbi);
Namjae Jeona07ef782012-12-30 14:52:05 +09003537 if (err) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003538 f2fs_err(sbi, "Failed to initialize F2FS node manager (%d)",
3539 err);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003540 goto free_nm;
Namjae Jeona07ef782012-12-30 14:52:05 +09003541 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003542
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08003543 /* For write statistics */
3544 if (sb->s_bdev->bd_part)
3545 sbi->sectors_written_start =
Michael Callahandbae2c52018-07-18 04:47:38 -07003546 (u64)part_stat_read(sb->s_bdev->bd_part,
3547 sectors[STAT_WRITE]);
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08003548
3549 /* Read accumulated write IO statistics if exists */
3550 seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);
3551 if (__exist_node_summaries(sbi))
3552 sbi->kbytes_written =
Shuoran Liub2dde6f2016-03-29 18:00:15 +08003553 le64_to_cpu(seg_i->journal->info.kbytes_written);
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08003554
Chao Yu4d57b862018-05-30 00:20:41 +08003555 f2fs_build_gc_manager(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003556
Sahitya Tummala60aa4d52018-12-26 11:20:29 +05303557 err = f2fs_build_stats(sbi);
3558 if (err)
3559 goto free_nm;
3560
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003561 /* get an inode for node space */
3562 sbi->node_inode = f2fs_iget(sb, F2FS_NODE_INO(sbi));
3563 if (IS_ERR(sbi->node_inode)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003564 f2fs_err(sbi, "Failed to read node inode");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003565 err = PTR_ERR(sbi->node_inode);
Sahitya Tummala60aa4d52018-12-26 11:20:29 +05303566 goto free_stats;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003567 }
3568
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003569 /* read root inode and dentry */
3570 root = f2fs_iget(sb, F2FS_ROOT_INO(sbi));
3571 if (IS_ERR(root)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003572 f2fs_err(sbi, "Failed to read root inode");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003573 err = PTR_ERR(root);
Sahitya Tummala60aa4d52018-12-26 11:20:29 +05303574 goto free_node_inode;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003575 }
Chao Yubcbfbd62018-06-29 00:19:25 +08003576 if (!S_ISDIR(root->i_mode) || !root->i_blocks ||
3577 !root->i_size || !root->i_nlink) {
Chao Yu9d847952014-07-25 12:55:09 +08003578 iput(root);
Chao Yu8f99a942013-11-28 15:43:43 +08003579 err = -EINVAL;
Sahitya Tummala60aa4d52018-12-26 11:20:29 +05303580 goto free_node_inode;
Chao Yu8f99a942013-11-28 15:43:43 +08003581 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003582
3583 sb->s_root = d_make_root(root); /* allocate root dentry */
3584 if (!sb->s_root) {
3585 err = -ENOMEM;
Chengguang Xu025cdb162019-01-23 15:49:44 +08003586 goto free_node_inode;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003587 }
3588
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -07003589 err = f2fs_register_sysfs(sbi);
Namjae Jeonb59d0ba2013-08-04 23:09:40 +09003590 if (err)
Chao Yua3981012017-06-14 17:39:46 +08003591 goto free_root_inode;
Namjae Jeonb59d0ba2013-08-04 23:09:40 +09003592
Jaegeuk Kimea676732017-10-06 09:14:28 -07003593#ifdef CONFIG_QUOTA
Sheng Yong76cf05d2018-07-26 19:24:25 +08003594 /* Enable quota usage during mount */
Chao Yu7beb01f2018-10-24 18:34:26 +08003595 if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sb)) {
Jaegeuk Kimea676732017-10-06 09:14:28 -07003596 err = f2fs_enable_quotas(sb);
Jaegeuk Kim730746c2018-10-02 17:20:58 -07003597 if (err)
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003598 f2fs_err(sbi, "Cannot turn on quotas: error %d", err);
Jaegeuk Kimea676732017-10-06 09:14:28 -07003599 }
3600#endif
Chao Yu7a88ddb2020-02-27 19:30:05 +08003601 /* if there are any orphan inodes, free them */
Chao Yu4d57b862018-05-30 00:20:41 +08003602 err = f2fs_recover_orphan_inodes(sbi);
Chao Yu4b2414d2017-08-08 10:54:31 +08003603 if (err)
Jaegeuk Kimea676732017-10-06 09:14:28 -07003604 goto free_meta;
Chao Yu4b2414d2017-08-08 10:54:31 +08003605
Daniel Rosenberg43549942018-08-20 19:21:43 -07003606 if (unlikely(is_set_ckpt_flags(sbi, CP_DISABLED_FLAG)))
Chao Yuaa2c8c42019-02-19 16:23:53 +08003607 goto reset_checkpoint;
Daniel Rosenberg43549942018-08-20 19:21:43 -07003608
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003609 /* recover fsynced data */
Chao Yua9117ec2020-02-14 17:45:11 +08003610 if (!test_opt(sbi, DISABLE_ROLL_FORWARD) &&
3611 !test_opt(sbi, NORECOVERY)) {
Jaegeuk Kim081d78c2015-01-23 19:16:59 -08003612 /*
3613 * mount should be failed, when device has readonly mode, and
3614 * previous checkpoint was not done by clean system shutdown.
3615 */
Chao Yub61af312019-04-22 20:22:37 +08003616 if (f2fs_hw_is_readonly(sbi)) {
3617 if (!is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
3618 err = -EROFS;
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003619 f2fs_err(sbi, "Need to recover fsync data, but write access unavailable");
Chao Yub61af312019-04-22 20:22:37 +08003620 goto free_meta;
3621 }
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003622 f2fs_info(sbi, "write access unavailable, skipping recovery");
Chao Yub61af312019-04-22 20:22:37 +08003623 goto reset_checkpoint;
Jaegeuk Kim081d78c2015-01-23 19:16:59 -08003624 }
Chao Yu2adc3502015-03-16 21:08:44 +08003625
3626 if (need_fsck)
3627 set_sbi_flag(sbi, SBI_NEED_FSCK);
3628
Chao Yuaa2c8c42019-02-19 16:23:53 +08003629 if (skip_recovery)
3630 goto reset_checkpoint;
Jaegeuk Kima468f0e2016-09-19 17:55:10 -07003631
Chao Yu4d57b862018-05-30 00:20:41 +08003632 err = f2fs_recover_fsync_data(sbi, false);
Jaegeuk Kim6781eab2016-03-23 16:12:58 -07003633 if (err < 0) {
Chao Yuaa2c8c42019-02-19 16:23:53 +08003634 if (err != -ENOMEM)
3635 skip_recovery = true;
Chao Yu2adc3502015-03-16 21:08:44 +08003636 need_fsck = true;
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003637 f2fs_err(sbi, "Cannot recover all fsync data errno=%d",
3638 err);
Chao Yu4b2414d2017-08-08 10:54:31 +08003639 goto free_meta;
Jaegeuk Kimed2e6212014-08-08 15:37:41 -07003640 }
Jaegeuk Kim6781eab2016-03-23 16:12:58 -07003641 } else {
Chao Yu4d57b862018-05-30 00:20:41 +08003642 err = f2fs_recover_fsync_data(sbi, true);
Jaegeuk Kim6781eab2016-03-23 16:12:58 -07003643
3644 if (!f2fs_readonly(sb) && err > 0) {
3645 err = -EINVAL;
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003646 f2fs_err(sbi, "Need to recover fsync data");
Jaegeuk Kimea676732017-10-06 09:14:28 -07003647 goto free_meta;
Jaegeuk Kim6781eab2016-03-23 16:12:58 -07003648 }
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003649 }
Shin'ichiro Kawasakid508c942019-12-09 19:44:45 +09003650
3651 /*
3652 * If the f2fs is not readonly and fsync data recovery succeeds,
3653 * check zoned block devices' write pointer consistency.
3654 */
3655 if (!err && !f2fs_readonly(sb) && f2fs_sb_has_blkzoned(sbi)) {
3656 err = f2fs_check_write_pointer(sbi);
3657 if (err)
3658 goto free_meta;
3659 }
3660
Chao Yuaa2c8c42019-02-19 16:23:53 +08003661reset_checkpoint:
Chao Yu4d57b862018-05-30 00:20:41 +08003662 /* f2fs_recover_fsync_data() cleared this already */
Jaegeuk Kim315df832015-08-11 12:45:39 -07003663 clear_sbi_flag(sbi, SBI_POR_DOING);
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003664
Daniel Rosenberg43549942018-08-20 19:21:43 -07003665 if (test_opt(sbi, DISABLE_CHECKPOINT)) {
3666 err = f2fs_disable_checkpoint(sbi);
3667 if (err)
Jaegeuk Kim812a9592019-01-22 14:04:33 -08003668 goto sync_free_meta;
Daniel Rosenberg43549942018-08-20 19:21:43 -07003669 } else if (is_set_ckpt_flags(sbi, CP_DISABLED_FLAG)) {
3670 f2fs_enable_checkpoint(sbi);
3671 }
3672
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003673 /*
3674 * If filesystem is not mounted as read-only then
3675 * do start the gc_thread.
3676 */
Chao Yubbbc34f2020-02-14 17:44:13 +08003677 if (F2FS_OPTION(sbi).bggc_mode != BGGC_MODE_OFF && !f2fs_readonly(sb)) {
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003678 /* After POR, we can run background GC thread.*/
Chao Yu4d57b862018-05-30 00:20:41 +08003679 err = f2fs_start_gc_thread(sbi);
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003680 if (err)
Jaegeuk Kim812a9592019-01-22 14:04:33 -08003681 goto sync_free_meta;
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003682 }
Jaegeuk Kim52225952018-12-13 18:38:33 -08003683 kvfree(options);
hujianyangda554e42015-05-21 14:42:53 +08003684
3685 /* recover broken superblock */
Jaegeuk Kimf2353d72016-03-23 10:42:01 -07003686 if (recovery) {
Chao Yu41214b32016-02-22 18:33:20 +08003687 err = f2fs_commit_super(sbi, true);
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003688 f2fs_info(sbi, "Try to recover %dth superblock, ret: %d",
3689 sbi->valid_super_block ? 1 : 2, err);
hujianyangda554e42015-05-21 14:42:53 +08003690 }
3691
Chao Yubae01ed2017-11-30 19:28:20 +08003692 f2fs_join_shrinker(sbi);
3693
Jaegeuk Kim84b89e52018-02-22 14:09:30 -08003694 f2fs_tuning_parameters(sbi);
3695
Joe Perchesdcbb4c12019-06-18 17:48:42 +08003696 f2fs_notice(sbi, "Mounted with checkpoint version = %llx",
3697 cur_cp_version(F2FS_CKPT(sbi)));
Jaegeuk Kim6beceb52016-01-08 15:51:50 -08003698 f2fs_update_time(sbi, CP_TIME);
Jaegeuk Kimd0239e12016-01-08 16:57:48 -08003699 f2fs_update_time(sbi, REQ_TIME);
Jaegeuk Kimdb610a62019-01-24 17:48:38 -08003700 clear_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003701 return 0;
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003702
Jaegeuk Kim812a9592019-01-22 14:04:33 -08003703sync_free_meta:
3704 /* safe to flush all the data */
3705 sync_filesystem(sbi->sb);
Chao Yuaa2c8c42019-02-19 16:23:53 +08003706 retry_cnt = 0;
Jaegeuk Kim812a9592019-01-22 14:04:33 -08003707
Chao Yu4b2414d2017-08-08 10:54:31 +08003708free_meta:
Jaegeuk Kimea676732017-10-06 09:14:28 -07003709#ifdef CONFIG_QUOTA
Sheng Yong26b5a072018-10-12 18:49:26 +08003710 f2fs_truncate_quota_inode_pages(sb);
Chao Yu7beb01f2018-10-24 18:34:26 +08003711 if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sb))
Jaegeuk Kimea676732017-10-06 09:14:28 -07003712 f2fs_quota_off_umount(sbi->sb);
3713#endif
Chao Yu4b2414d2017-08-08 10:54:31 +08003714 /*
Chao Yu4d57b862018-05-30 00:20:41 +08003715 * Some dirty meta pages can be produced by f2fs_recover_orphan_inodes()
Chao Yu4b2414d2017-08-08 10:54:31 +08003716 * failed by EIO. Then, iput(node_inode) can trigger balance_fs_bg()
Chao Yu4d57b862018-05-30 00:20:41 +08003717 * followed by f2fs_write_checkpoint() through f2fs_write_node_pages(), which
3718 * falls into an infinite loop in f2fs_sync_meta_pages().
Chao Yu4b2414d2017-08-08 10:54:31 +08003719 */
3720 truncate_inode_pages_final(META_MAPPING(sbi));
Jaegeuk Kim812a9592019-01-22 14:04:33 -08003721 /* evict some inodes being cached by GC */
3722 evict_inodes(sb);
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -07003723 f2fs_unregister_sysfs(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003724free_root_inode:
3725 dput(sb->s_root);
3726 sb->s_root = NULL;
Chao Yubae01ed2017-11-30 19:28:20 +08003727free_node_inode:
Chao Yu4d57b862018-05-30 00:20:41 +08003728 f2fs_release_ino_entry(sbi, true);
Chao Yubae01ed2017-11-30 19:28:20 +08003729 truncate_inode_pages_final(NODE_MAPPING(sbi));
3730 iput(sbi->node_inode);
Jaegeuk Kim7c77bf72019-01-01 00:11:30 -08003731 sbi->node_inode = NULL;
Sahitya Tummala60aa4d52018-12-26 11:20:29 +05303732free_stats:
3733 f2fs_destroy_stats(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003734free_nm:
Chao Yu4d57b862018-05-30 00:20:41 +08003735 f2fs_destroy_node_manager(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003736free_sm:
Chao Yu4d57b862018-05-30 00:20:41 +08003737 f2fs_destroy_segment_manager(sbi);
Chao Yu4c8ff702019-11-01 18:07:14 +08003738 f2fs_destroy_post_read_wq(sbi);
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003739free_devices:
3740 destroy_device_list(sbi);
Jaegeuk Kim52225952018-12-13 18:38:33 -08003741 kvfree(sbi->ckpt);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003742free_meta_inode:
3743 make_bad_inode(sbi->meta_inode);
3744 iput(sbi->meta_inode);
Jaegeuk Kim7c77bf72019-01-01 00:11:30 -08003745 sbi->meta_inode = NULL;
Chao Yua9991502020-02-25 18:17:10 +08003746free_xattr_cache:
3747 f2fs_destroy_xattr_caches(sbi);
Jaegeuk Kim0a595eb2016-12-14 10:12:56 -08003748free_io_dummy:
3749 mempool_destroy(sbi->write_io_dummy);
Chao Yud7997e62018-01-17 16:31:35 +08003750free_percpu:
3751 destroy_percpu_info(sbi);
3752free_bio_info:
Jaegeuk Kima912b542017-05-10 11:18:25 -07003753 for (i = 0; i < NR_PAGE_TYPE; i++)
Jaegeuk Kim52225952018-12-13 18:38:33 -08003754 kvfree(sbi->write_io[i]);
Daniel Rosenberg5aba5432019-07-23 16:05:28 -07003755
3756#ifdef CONFIG_UNICODE
3757 utf8_unload(sbi->s_encoding);
3758#endif
Chao Yud7997e62018-01-17 16:31:35 +08003759free_options:
Chao Yu4b2414d2017-08-08 10:54:31 +08003760#ifdef CONFIG_QUOTA
3761 for (i = 0; i < MAXQUOTAS; i++)
Jaegeuk Kim52225952018-12-13 18:38:33 -08003762 kvfree(F2FS_OPTION(sbi).s_qf_names[i]);
Chao Yu4b2414d2017-08-08 10:54:31 +08003763#endif
Jaegeuk Kim52225952018-12-13 18:38:33 -08003764 kvfree(options);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003765free_sb_buf:
Jaegeuk Kim52225952018-12-13 18:38:33 -08003766 kvfree(raw_super);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003767free_sbi:
Keith Mok43b65732016-03-02 12:04:24 -08003768 if (sbi->s_chksum_driver)
3769 crypto_free_shash(sbi->s_chksum_driver);
Jaegeuk Kim52225952018-12-13 18:38:33 -08003770 kvfree(sbi);
Jaegeuk Kimed2e6212014-08-08 15:37:41 -07003771
3772 /* give only one another chance */
Chao Yuaa2c8c42019-02-19 16:23:53 +08003773 if (retry_cnt > 0 && skip_recovery) {
3774 retry_cnt--;
Jaegeuk Kimed2e6212014-08-08 15:37:41 -07003775 shrink_dcache_sb(sb);
3776 goto try_onemore;
3777 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003778 return err;
3779}
3780
3781static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags,
3782 const char *dev_name, void *data)
3783{
3784 return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super);
3785}
3786
Jaegeuk Kim30a55372015-01-14 16:34:24 -08003787static void kill_f2fs_super(struct super_block *sb)
3788{
Chao Yucce13252017-06-29 23:17:45 +08003789 if (sb->s_root) {
Jaegeuk Kim1cb50f82018-07-06 16:47:34 -07003790 struct f2fs_sb_info *sbi = F2FS_SB(sb);
3791
3792 set_sbi_flag(sbi, SBI_IS_CLOSE);
3793 f2fs_stop_gc_thread(sbi);
3794 f2fs_stop_discard_thread(sbi);
3795
3796 if (is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||
3797 !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
3798 struct cp_control cpc = {
3799 .reason = CP_UMOUNT,
3800 };
3801 f2fs_write_checkpoint(sbi, &cpc);
3802 }
Chao Yu13787522018-08-22 17:11:05 +08003803
3804 if (is_sbi_flag_set(sbi, SBI_IS_RECOVERED) && f2fs_readonly(sb))
3805 sb->s_flags &= ~SB_RDONLY;
Chao Yucce13252017-06-29 23:17:45 +08003806 }
Jaegeuk Kim30a55372015-01-14 16:34:24 -08003807 kill_block_super(sb);
3808}
3809
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003810static struct file_system_type f2fs_fs_type = {
3811 .owner = THIS_MODULE,
3812 .name = "f2fs",
3813 .mount = f2fs_mount,
Jaegeuk Kim30a55372015-01-14 16:34:24 -08003814 .kill_sb = kill_f2fs_super,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003815 .fs_flags = FS_REQUIRES_DEV,
3816};
Eric W. Biederman7f78e032013-03-02 19:39:14 -08003817MODULE_ALIAS_FS("f2fs");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003818
Namjae Jeon6e6093a2013-01-17 00:08:30 +09003819static int __init init_inodecache(void)
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003820{
Vladimir Davydov5d097052016-01-14 15:18:21 -08003821 f2fs_inode_cachep = kmem_cache_create("f2fs_inode_cache",
3822 sizeof(struct f2fs_inode_info), 0,
3823 SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT, NULL);
Jaegeuk Kim6bacf522013-12-06 15:00:58 +09003824 if (!f2fs_inode_cachep)
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003825 return -ENOMEM;
3826 return 0;
3827}
3828
3829static void destroy_inodecache(void)
3830{
3831 /*
3832 * Make sure all delayed rcu free inodes are flushed before we
3833 * destroy cache.
3834 */
3835 rcu_barrier();
3836 kmem_cache_destroy(f2fs_inode_cachep);
3837}
3838
3839static int __init init_f2fs_fs(void)
3840{
3841 int err;
3842
Anatoly Pugachev4071e672018-05-28 02:06:37 +03003843 if (PAGE_SIZE != F2FS_BLKSIZE) {
3844 printk("F2FS not supported on PAGE_SIZE(%lu) != %d\n",
3845 PAGE_SIZE, F2FS_BLKSIZE);
3846 return -EINVAL;
3847 }
3848
Jaegeuk Kimc0508652015-01-07 14:07:36 -08003849 f2fs_build_trace_ios();
3850
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003851 err = init_inodecache();
3852 if (err)
3853 goto fail;
Chao Yu4d57b862018-05-30 00:20:41 +08003854 err = f2fs_create_node_manager_caches();
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003855 if (err)
Zhao Hongjiang9890ff32013-08-20 16:49:51 +08003856 goto free_inodecache;
Chao Yu4d57b862018-05-30 00:20:41 +08003857 err = f2fs_create_segment_manager_caches();
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003858 if (err)
Zhao Hongjiang9890ff32013-08-20 16:49:51 +08003859 goto free_node_manager_caches;
Chao Yu4d57b862018-05-30 00:20:41 +08003860 err = f2fs_create_checkpoint_caches();
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003861 if (err)
Chao Yu06292072014-12-29 15:56:18 +08003862 goto free_segment_manager_caches;
Chao Yu4d57b862018-05-30 00:20:41 +08003863 err = f2fs_create_extent_cache();
Chao Yu1dcc3362015-02-05 17:57:31 +08003864 if (err)
3865 goto free_checkpoint_caches;
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -07003866 err = f2fs_init_sysfs();
Chao Yua3981012017-06-14 17:39:46 +08003867 if (err)
Chao Yu1dcc3362015-02-05 17:57:31 +08003868 goto free_extent_cache;
Jaegeuk Kim2658e502015-06-19 12:01:21 -07003869 err = register_shrinker(&f2fs_shrinker_info);
Jaegeuk Kimcfc4d972015-05-15 15:37:24 -07003870 if (err)
Chao Yua3981012017-06-14 17:39:46 +08003871 goto free_sysfs;
Jaegeuk Kim2658e502015-06-19 12:01:21 -07003872 err = register_filesystem(&f2fs_fs_type);
3873 if (err)
3874 goto free_shrinker;
Greg Kroah-Hartman21acc072019-01-04 14:26:18 +01003875 f2fs_create_root_stats();
Eric Biggers6dbb1792018-04-18 11:09:48 -07003876 err = f2fs_init_post_read_processing();
3877 if (err)
3878 goto free_root_stats;
Chao Yu0b20fce2019-09-30 18:53:25 +08003879 err = f2fs_init_bio_entry_cache();
3880 if (err)
3881 goto free_post_read;
Chao Yuf5438052019-12-04 09:52:58 +08003882 err = f2fs_init_bioset();
3883 if (err)
3884 goto free_bio_enrty_cache;
Zhao Hongjiang9890ff32013-08-20 16:49:51 +08003885 return 0;
Chao Yuf5438052019-12-04 09:52:58 +08003886free_bio_enrty_cache:
3887 f2fs_destroy_bio_entry_cache();
Chao Yu0b20fce2019-09-30 18:53:25 +08003888free_post_read:
3889 f2fs_destroy_post_read_processing();
Eric Biggers6dbb1792018-04-18 11:09:48 -07003890free_root_stats:
3891 f2fs_destroy_root_stats();
Chao Yu787c7b8c2015-10-29 09:13:04 +08003892 unregister_filesystem(&f2fs_fs_type);
Jaegeuk Kim2658e502015-06-19 12:01:21 -07003893free_shrinker:
3894 unregister_shrinker(&f2fs_shrinker_info);
Chao Yua3981012017-06-14 17:39:46 +08003895free_sysfs:
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -07003896 f2fs_exit_sysfs();
Chao Yu1dcc3362015-02-05 17:57:31 +08003897free_extent_cache:
Chao Yu4d57b862018-05-30 00:20:41 +08003898 f2fs_destroy_extent_cache();
Zhao Hongjiang9890ff32013-08-20 16:49:51 +08003899free_checkpoint_caches:
Chao Yu4d57b862018-05-30 00:20:41 +08003900 f2fs_destroy_checkpoint_caches();
Jaegeuk Kim7fd9e542013-11-15 13:55:58 +09003901free_segment_manager_caches:
Chao Yu4d57b862018-05-30 00:20:41 +08003902 f2fs_destroy_segment_manager_caches();
Zhao Hongjiang9890ff32013-08-20 16:49:51 +08003903free_node_manager_caches:
Chao Yu4d57b862018-05-30 00:20:41 +08003904 f2fs_destroy_node_manager_caches();
Zhao Hongjiang9890ff32013-08-20 16:49:51 +08003905free_inodecache:
3906 destroy_inodecache();
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003907fail:
3908 return err;
3909}
3910
3911static void __exit exit_f2fs_fs(void)
3912{
Chao Yuf5438052019-12-04 09:52:58 +08003913 f2fs_destroy_bioset();
Chao Yu0b20fce2019-09-30 18:53:25 +08003914 f2fs_destroy_bio_entry_cache();
Eric Biggers6dbb1792018-04-18 11:09:48 -07003915 f2fs_destroy_post_read_processing();
Namjae Jeon4589d252013-01-15 19:58:47 +09003916 f2fs_destroy_root_stats();
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003917 unregister_filesystem(&f2fs_fs_type);
Tiezhu Yangb8bef792016-05-18 08:02:25 +08003918 unregister_shrinker(&f2fs_shrinker_info);
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -07003919 f2fs_exit_sysfs();
Chao Yu4d57b862018-05-30 00:20:41 +08003920 f2fs_destroy_extent_cache();
3921 f2fs_destroy_checkpoint_caches();
3922 f2fs_destroy_segment_manager_caches();
3923 f2fs_destroy_node_manager_caches();
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003924 destroy_inodecache();
Jaegeuk Kim351f4fb2015-01-07 14:09:48 -08003925 f2fs_destroy_trace_ios();
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003926}
3927
3928module_init(init_f2fs_fs)
3929module_exit(exit_f2fs_fs)
3930
3931MODULE_AUTHOR("Samsung Electronics's Praesto Team");
3932MODULE_DESCRIPTION("Flash Friendly File System");
3933MODULE_LICENSE("GPL");
Jaegeuk Kimb4b9d342016-11-04 14:59:15 -07003934