blob: 45121190a2ba485f01b6d1151bb466b762e4149a [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>
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090026
27#include "f2fs.h"
28#include "node.h"
Jaegeuk Kim5ec4e492013-03-31 13:26:03 +090029#include "segment.h"
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090030#include "xattr.h"
Namjae Jeonb59d0ba2013-08-04 23:09:40 +090031#include "gc.h"
Jaegeuk Kimdb9f7c12014-12-17 20:04:08 -080032#include "trace.h"
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090033
Namjae Jeona2a4a7e2013-04-20 01:28:40 +090034#define CREATE_TRACE_POINTS
35#include <trace/events/f2fs.h>
36
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090037static struct kmem_cache *f2fs_inode_cachep;
38
Jaegeuk Kim73faec42016-04-29 15:34:32 -070039#ifdef CONFIG_F2FS_FAULT_INJECTION
Jaegeuk Kim2c63fea2016-04-29 15:49:56 -070040
Alexey Dobriyan19880e62018-11-24 12:06:42 +030041const char *f2fs_fault_name[FAULT_MAX] = {
Jaegeuk Kim2c63fea2016-04-29 15:49:56 -070042 [FAULT_KMALLOC] = "kmalloc",
Chao Yu628b3d12017-11-30 19:28:18 +080043 [FAULT_KVMALLOC] = "kvmalloc",
Jaegeuk Kimc41f3cc32016-04-29 16:17:09 -070044 [FAULT_PAGE_ALLOC] = "page alloc",
Chao Yu01eccef2017-10-28 16:52:30 +080045 [FAULT_PAGE_GET] = "page get",
Chao Yud62fe972017-10-28 16:52:31 +080046 [FAULT_ALLOC_BIO] = "alloc bio",
Jaegeuk Kimcb789422016-04-29 16:29:22 -070047 [FAULT_ALLOC_NID] = "alloc nid",
48 [FAULT_ORPHAN] = "orphan",
49 [FAULT_BLOCK] = "no more block",
50 [FAULT_DIR_DEPTH] = "too big dir depth",
Jaegeuk Kim53aa6bb2016-05-25 15:24:18 -070051 [FAULT_EVICT_INODE] = "evict_inode fail",
Jaegeuk Kim14b44d22017-03-09 15:24:24 -080052 [FAULT_TRUNCATE] = "truncate fail",
Chao Yu6f5c2ed2018-09-12 09:22:29 +080053 [FAULT_READ_IO] = "read IO error",
Chao Yu0f348022016-09-26 19:45:55 +080054 [FAULT_CHECKPOINT] = "checkpoint error",
Chao Yub83dcfe2018-08-06 20:30:18 +080055 [FAULT_DISCARD] = "discard error",
Chao Yu6f5c2ed2018-09-12 09:22:29 +080056 [FAULT_WRITE_IO] = "write IO error",
Jaegeuk Kim2c63fea2016-04-29 15:49:56 -070057};
Sheng Yong08796892016-05-16 12:38:50 +080058
Chao Yud4945002018-08-08 17:36:41 +080059void f2fs_build_fault_attr(struct f2fs_sb_info *sbi, unsigned int rate,
60 unsigned int type)
Sheng Yong08796892016-05-16 12:38:50 +080061{
Chao Yu63189b72018-03-08 14:22:56 +080062 struct f2fs_fault_info *ffi = &F2FS_OPTION(sbi).fault_info;
Chao Yu1ecc0c52016-09-23 21:30:09 +080063
Sheng Yong08796892016-05-16 12:38:50 +080064 if (rate) {
Chao Yu1ecc0c52016-09-23 21:30:09 +080065 atomic_set(&ffi->inject_ops, 0);
66 ffi->inject_rate = rate;
Sheng Yong08796892016-05-16 12:38:50 +080067 }
Chao Yud4945002018-08-08 17:36:41 +080068
69 if (type)
70 ffi->inject_type = type;
71
72 if (!rate && !type)
73 memset(ffi, 0, sizeof(struct f2fs_fault_info));
Sheng Yong08796892016-05-16 12:38:50 +080074}
Jaegeuk Kim73faec42016-04-29 15:34:32 -070075#endif
76
Jaegeuk Kim2658e502015-06-19 12:01:21 -070077/* f2fs-wide shrinker description */
78static struct shrinker f2fs_shrinker_info = {
79 .scan_objects = f2fs_shrink_scan,
80 .count_objects = f2fs_shrink_count,
81 .seeks = DEFAULT_SEEKS,
82};
83
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090084enum {
Namjae Jeon696c0182013-06-16 09:48:48 +090085 Opt_gc_background,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090086 Opt_disable_roll_forward,
Jaegeuk Kim2d834bf2015-01-23 18:33:46 -080087 Opt_norecovery,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090088 Opt_discard,
Chao Yu64058be2016-07-03 22:05:14 +080089 Opt_nodiscard,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090090 Opt_noheap,
Jaegeuk Kim7a20b8a2017-03-24 20:41:45 -040091 Opt_heap,
Kelly Anderson4058c512013-10-07 11:36:20 +090092 Opt_user_xattr,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090093 Opt_nouser_xattr,
Kelly Anderson4058c512013-10-07 11:36:20 +090094 Opt_acl,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +090095 Opt_noacl,
96 Opt_active_logs,
97 Opt_disable_ext_identify,
Jaegeuk Kim444c5802013-08-08 15:16:22 +090098 Opt_inline_xattr,
Chao Yu23cf7212017-02-15 10:34:45 +080099 Opt_noinline_xattr,
Chao Yu6afc6622017-09-06 21:59:50 +0800100 Opt_inline_xattr_size,
Huajun Li8274de72013-11-10 23:13:17 +0800101 Opt_inline_data,
Chao Yu5efd3c62014-09-24 18:16:13 +0800102 Opt_inline_dentry,
Chao Yu97c17942016-05-09 19:56:34 +0800103 Opt_noinline_dentry,
Jaegeuk Kim6b4afdd2014-04-02 15:34:36 +0900104 Opt_flush_merge,
Jaegeuk Kim69e9e422016-05-20 22:39:20 -0700105 Opt_noflush_merge,
Jaegeuk Kim0f7b2ab2014-07-23 09:57:31 -0700106 Opt_nobarrier,
Jaegeuk Kimd5053a342014-10-30 22:47:03 -0700107 Opt_fastboot,
Chao Yu89672152015-02-05 17:55:51 +0800108 Opt_extent_cache,
Jaegeuk Kim7daaea22015-06-25 17:43:04 -0700109 Opt_noextent_cache,
Wanpeng Li75342792015-03-24 10:20:27 +0800110 Opt_noinline_data,
Chao Yu343f40f2015-12-16 13:12:16 +0800111 Opt_data_flush,
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800112 Opt_reserve_root,
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800113 Opt_resgid,
114 Opt_resuid,
Jaegeuk Kim36abef42016-06-03 19:29:38 -0700115 Opt_mode,
Jaegeuk Kimec915382016-12-21 17:09:19 -0800116 Opt_io_size_bits,
Jaegeuk Kim73faec42016-04-29 15:34:32 -0700117 Opt_fault_injection,
Chao Yud4945002018-08-08 17:36:41 +0800118 Opt_fault_type,
Jaegeuk Kim6d94c742016-05-20 21:47:24 -0700119 Opt_lazytime,
120 Opt_nolazytime,
Chao Yu4b2414d2017-08-08 10:54:31 +0800121 Opt_quota,
122 Opt_noquota,
Chao Yu0abd6752017-07-09 00:13:07 +0800123 Opt_usrquota,
124 Opt_grpquota,
Chao Yu5c571322017-07-26 00:01:41 +0800125 Opt_prjquota,
Chao Yu4b2414d2017-08-08 10:54:31 +0800126 Opt_usrjquota,
127 Opt_grpjquota,
128 Opt_prjjquota,
129 Opt_offusrjquota,
130 Opt_offgrpjquota,
131 Opt_offprjjquota,
132 Opt_jqfmt_vfsold,
133 Opt_jqfmt_vfsv0,
134 Opt_jqfmt_vfsv1,
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900135 Opt_whint,
Jaegeuk Kim07939622018-02-18 08:50:49 -0800136 Opt_alloc,
Junling Zheng93cf93f2018-03-07 12:07:49 +0800137 Opt_fsync,
Sheng Yongff62af22018-03-15 18:51:42 +0800138 Opt_test_dummy_encryption,
Daniel Rosenberg43549942018-08-20 19:21:43 -0700139 Opt_checkpoint,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900140 Opt_err,
141};
142
143static match_table_t f2fs_tokens = {
Namjae Jeon696c0182013-06-16 09:48:48 +0900144 {Opt_gc_background, "background_gc=%s"},
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900145 {Opt_disable_roll_forward, "disable_roll_forward"},
Jaegeuk Kim2d834bf2015-01-23 18:33:46 -0800146 {Opt_norecovery, "norecovery"},
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900147 {Opt_discard, "discard"},
Chao Yu64058be2016-07-03 22:05:14 +0800148 {Opt_nodiscard, "nodiscard"},
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900149 {Opt_noheap, "no_heap"},
Jaegeuk Kim7a20b8a2017-03-24 20:41:45 -0400150 {Opt_heap, "heap"},
Kelly Anderson4058c512013-10-07 11:36:20 +0900151 {Opt_user_xattr, "user_xattr"},
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900152 {Opt_nouser_xattr, "nouser_xattr"},
Kelly Anderson4058c512013-10-07 11:36:20 +0900153 {Opt_acl, "acl"},
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900154 {Opt_noacl, "noacl"},
155 {Opt_active_logs, "active_logs=%u"},
156 {Opt_disable_ext_identify, "disable_ext_identify"},
Jaegeuk Kim444c5802013-08-08 15:16:22 +0900157 {Opt_inline_xattr, "inline_xattr"},
Chao Yu23cf7212017-02-15 10:34:45 +0800158 {Opt_noinline_xattr, "noinline_xattr"},
Chao Yu6afc6622017-09-06 21:59:50 +0800159 {Opt_inline_xattr_size, "inline_xattr_size=%u"},
Huajun Li8274de72013-11-10 23:13:17 +0800160 {Opt_inline_data, "inline_data"},
Chao Yu5efd3c62014-09-24 18:16:13 +0800161 {Opt_inline_dentry, "inline_dentry"},
Chao Yu97c17942016-05-09 19:56:34 +0800162 {Opt_noinline_dentry, "noinline_dentry"},
Jaegeuk Kim6b4afdd2014-04-02 15:34:36 +0900163 {Opt_flush_merge, "flush_merge"},
Jaegeuk Kim69e9e422016-05-20 22:39:20 -0700164 {Opt_noflush_merge, "noflush_merge"},
Jaegeuk Kim0f7b2ab2014-07-23 09:57:31 -0700165 {Opt_nobarrier, "nobarrier"},
Jaegeuk Kimd5053a342014-10-30 22:47:03 -0700166 {Opt_fastboot, "fastboot"},
Chao Yu89672152015-02-05 17:55:51 +0800167 {Opt_extent_cache, "extent_cache"},
Jaegeuk Kim7daaea22015-06-25 17:43:04 -0700168 {Opt_noextent_cache, "noextent_cache"},
Wanpeng Li75342792015-03-24 10:20:27 +0800169 {Opt_noinline_data, "noinline_data"},
Chao Yu343f40f2015-12-16 13:12:16 +0800170 {Opt_data_flush, "data_flush"},
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800171 {Opt_reserve_root, "reserve_root=%u"},
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800172 {Opt_resgid, "resgid=%u"},
173 {Opt_resuid, "resuid=%u"},
Jaegeuk Kim36abef42016-06-03 19:29:38 -0700174 {Opt_mode, "mode=%s"},
Jaegeuk Kimec915382016-12-21 17:09:19 -0800175 {Opt_io_size_bits, "io_bits=%u"},
Jaegeuk Kim73faec42016-04-29 15:34:32 -0700176 {Opt_fault_injection, "fault_injection=%u"},
Chao Yud4945002018-08-08 17:36:41 +0800177 {Opt_fault_type, "fault_type=%u"},
Jaegeuk Kim6d94c742016-05-20 21:47:24 -0700178 {Opt_lazytime, "lazytime"},
179 {Opt_nolazytime, "nolazytime"},
Chao Yu4b2414d2017-08-08 10:54:31 +0800180 {Opt_quota, "quota"},
181 {Opt_noquota, "noquota"},
Chao Yu0abd6752017-07-09 00:13:07 +0800182 {Opt_usrquota, "usrquota"},
183 {Opt_grpquota, "grpquota"},
Chao Yu5c571322017-07-26 00:01:41 +0800184 {Opt_prjquota, "prjquota"},
Chao Yu4b2414d2017-08-08 10:54:31 +0800185 {Opt_usrjquota, "usrjquota=%s"},
186 {Opt_grpjquota, "grpjquota=%s"},
187 {Opt_prjjquota, "prjjquota=%s"},
188 {Opt_offusrjquota, "usrjquota="},
189 {Opt_offgrpjquota, "grpjquota="},
190 {Opt_offprjjquota, "prjjquota="},
191 {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
192 {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
193 {Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900194 {Opt_whint, "whint_mode=%s"},
Jaegeuk Kim07939622018-02-18 08:50:49 -0800195 {Opt_alloc, "alloc_mode=%s"},
Junling Zheng93cf93f2018-03-07 12:07:49 +0800196 {Opt_fsync, "fsync_mode=%s"},
Sheng Yongff62af22018-03-15 18:51:42 +0800197 {Opt_test_dummy_encryption, "test_dummy_encryption"},
Daniel Rosenberg43549942018-08-20 19:21:43 -0700198 {Opt_checkpoint, "checkpoint=%s"},
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900199 {Opt_err, NULL},
200};
201
Namjae Jeona07ef782012-12-30 14:52:05 +0900202void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...)
203{
204 struct va_format vaf;
205 va_list args;
206
207 va_start(args, fmt);
208 vaf.fmt = fmt;
209 vaf.va = &args;
Chao Yu22d7ea12018-08-22 17:17:47 +0800210 printk("%sF2FS-fs (%s): %pV\n", level, sb->s_id, &vaf);
Namjae Jeona07ef782012-12-30 14:52:05 +0900211 va_end(args);
212}
213
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800214static inline void limit_reserve_root(struct f2fs_sb_info *sbi)
215{
216 block_t limit = (sbi->user_block_count << 1) / 1000;
217
218 /* limit is 0.2% */
Chao Yu63189b72018-03-08 14:22:56 +0800219 if (test_opt(sbi, RESERVE_ROOT) &&
220 F2FS_OPTION(sbi).root_reserved_blocks > limit) {
221 F2FS_OPTION(sbi).root_reserved_blocks = limit;
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800222 f2fs_msg(sbi->sb, KERN_INFO,
223 "Reduce reserved blocks for root = %u",
Chao Yu63189b72018-03-08 14:22:56 +0800224 F2FS_OPTION(sbi).root_reserved_blocks);
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800225 }
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800226 if (!test_opt(sbi, RESERVE_ROOT) &&
Chao Yu63189b72018-03-08 14:22:56 +0800227 (!uid_eq(F2FS_OPTION(sbi).s_resuid,
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800228 make_kuid(&init_user_ns, F2FS_DEF_RESUID)) ||
Chao Yu63189b72018-03-08 14:22:56 +0800229 !gid_eq(F2FS_OPTION(sbi).s_resgid,
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800230 make_kgid(&init_user_ns, F2FS_DEF_RESGID))))
231 f2fs_msg(sbi->sb, KERN_INFO,
232 "Ignore s_resuid=%u, s_resgid=%u w/o reserve_root",
Chao Yu63189b72018-03-08 14:22:56 +0800233 from_kuid_munged(&init_user_ns,
234 F2FS_OPTION(sbi).s_resuid),
235 from_kgid_munged(&init_user_ns,
236 F2FS_OPTION(sbi).s_resgid));
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800237}
238
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900239static void init_once(void *foo)
240{
241 struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;
242
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900243 inode_init_once(&fi->vfs_inode);
244}
245
Chao Yu4b2414d2017-08-08 10:54:31 +0800246#ifdef CONFIG_QUOTA
247static const char * const quotatypes[] = INITQFNAMES;
248#define QTYPE2NAME(t) (quotatypes[t])
249static int f2fs_set_qf_name(struct super_block *sb, int qtype,
250 substring_t *args)
251{
252 struct f2fs_sb_info *sbi = F2FS_SB(sb);
253 char *qname;
254 int ret = -EINVAL;
255
Chao Yu63189b72018-03-08 14:22:56 +0800256 if (sb_any_quota_loaded(sb) && !F2FS_OPTION(sbi).s_qf_names[qtype]) {
Chao Yu4b2414d2017-08-08 10:54:31 +0800257 f2fs_msg(sb, KERN_ERR,
258 "Cannot change journaled "
259 "quota options when quota turned on");
260 return -EINVAL;
261 }
Chao Yu7beb01f2018-10-24 18:34:26 +0800262 if (f2fs_sb_has_quota_ino(sbi)) {
Jaegeuk Kimea676732017-10-06 09:14:28 -0700263 f2fs_msg(sb, KERN_INFO,
264 "QUOTA feature is enabled, so ignore qf_name");
265 return 0;
266 }
267
Chao Yu4b2414d2017-08-08 10:54:31 +0800268 qname = match_strdup(args);
269 if (!qname) {
270 f2fs_msg(sb, KERN_ERR,
271 "Not enough memory for storing quotafile name");
Chengguang Xuf365c6c2019-01-01 21:33:11 +0800272 return -ENOMEM;
Chao Yu4b2414d2017-08-08 10:54:31 +0800273 }
Chao Yu63189b72018-03-08 14:22:56 +0800274 if (F2FS_OPTION(sbi).s_qf_names[qtype]) {
275 if (strcmp(F2FS_OPTION(sbi).s_qf_names[qtype], qname) == 0)
Chao Yu4b2414d2017-08-08 10:54:31 +0800276 ret = 0;
277 else
278 f2fs_msg(sb, KERN_ERR,
279 "%s quota file already specified",
280 QTYPE2NAME(qtype));
281 goto errout;
282 }
283 if (strchr(qname, '/')) {
284 f2fs_msg(sb, KERN_ERR,
285 "quotafile must be on filesystem root");
286 goto errout;
287 }
Chao Yu63189b72018-03-08 14:22:56 +0800288 F2FS_OPTION(sbi).s_qf_names[qtype] = qname;
Chao Yu4b2414d2017-08-08 10:54:31 +0800289 set_opt(sbi, QUOTA);
290 return 0;
291errout:
Jaegeuk Kim52225952018-12-13 18:38:33 -0800292 kvfree(qname);
Chao Yu4b2414d2017-08-08 10:54:31 +0800293 return ret;
294}
295
296static int f2fs_clear_qf_name(struct super_block *sb, int qtype)
297{
298 struct f2fs_sb_info *sbi = F2FS_SB(sb);
299
Chao Yu63189b72018-03-08 14:22:56 +0800300 if (sb_any_quota_loaded(sb) && F2FS_OPTION(sbi).s_qf_names[qtype]) {
Chao Yu4b2414d2017-08-08 10:54:31 +0800301 f2fs_msg(sb, KERN_ERR, "Cannot change journaled quota options"
302 " when quota turned on");
303 return -EINVAL;
304 }
Jaegeuk Kim52225952018-12-13 18:38:33 -0800305 kvfree(F2FS_OPTION(sbi).s_qf_names[qtype]);
Chao Yu63189b72018-03-08 14:22:56 +0800306 F2FS_OPTION(sbi).s_qf_names[qtype] = NULL;
Chao Yu4b2414d2017-08-08 10:54:31 +0800307 return 0;
308}
309
310static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
311{
312 /*
313 * We do the test below only for project quotas. 'usrquota' and
314 * 'grpquota' mount options are allowed even without quota feature
315 * to support legacy quotas in quota files.
316 */
Chao Yu7beb01f2018-10-24 18:34:26 +0800317 if (test_opt(sbi, PRJQUOTA) && !f2fs_sb_has_project_quota(sbi)) {
Chao Yu4b2414d2017-08-08 10:54:31 +0800318 f2fs_msg(sbi->sb, KERN_ERR, "Project quota feature not enabled. "
319 "Cannot enable project quota enforcement.");
320 return -1;
321 }
Chao Yu63189b72018-03-08 14:22:56 +0800322 if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||
323 F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||
324 F2FS_OPTION(sbi).s_qf_names[PRJQUOTA]) {
325 if (test_opt(sbi, USRQUOTA) &&
326 F2FS_OPTION(sbi).s_qf_names[USRQUOTA])
Chao Yu4b2414d2017-08-08 10:54:31 +0800327 clear_opt(sbi, USRQUOTA);
328
Chao Yu63189b72018-03-08 14:22:56 +0800329 if (test_opt(sbi, GRPQUOTA) &&
330 F2FS_OPTION(sbi).s_qf_names[GRPQUOTA])
Chao Yu4b2414d2017-08-08 10:54:31 +0800331 clear_opt(sbi, GRPQUOTA);
332
Chao Yu63189b72018-03-08 14:22:56 +0800333 if (test_opt(sbi, PRJQUOTA) &&
334 F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])
Chao Yu4b2414d2017-08-08 10:54:31 +0800335 clear_opt(sbi, PRJQUOTA);
336
337 if (test_opt(sbi, GRPQUOTA) || test_opt(sbi, USRQUOTA) ||
338 test_opt(sbi, PRJQUOTA)) {
339 f2fs_msg(sbi->sb, KERN_ERR, "old and new quota "
340 "format mixing");
341 return -1;
342 }
343
Chao Yu63189b72018-03-08 14:22:56 +0800344 if (!F2FS_OPTION(sbi).s_jquota_fmt) {
Chao Yu4b2414d2017-08-08 10:54:31 +0800345 f2fs_msg(sbi->sb, KERN_ERR, "journaled quota format "
346 "not specified");
347 return -1;
348 }
349 }
Jaegeuk Kimea676732017-10-06 09:14:28 -0700350
Chao Yu7beb01f2018-10-24 18:34:26 +0800351 if (f2fs_sb_has_quota_ino(sbi) && F2FS_OPTION(sbi).s_jquota_fmt) {
Jaegeuk Kimea676732017-10-06 09:14:28 -0700352 f2fs_msg(sbi->sb, KERN_INFO,
353 "QUOTA feature is enabled, so ignore jquota_fmt");
Chao Yu63189b72018-03-08 14:22:56 +0800354 F2FS_OPTION(sbi).s_jquota_fmt = 0;
Jaegeuk Kimea676732017-10-06 09:14:28 -0700355 }
Chao Yu4b2414d2017-08-08 10:54:31 +0800356 return 0;
357}
358#endif
359
Namjae Jeon696c0182013-06-16 09:48:48 +0900360static int parse_options(struct super_block *sb, char *options)
361{
362 struct f2fs_sb_info *sbi = F2FS_SB(sb);
363 substring_t args[MAX_OPT_ARGS];
364 char *p, *name;
365 int arg = 0;
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800366 kuid_t uid;
367 kgid_t gid;
Chao Yu4b2414d2017-08-08 10:54:31 +0800368#ifdef CONFIG_QUOTA
369 int ret;
370#endif
Namjae Jeon696c0182013-06-16 09:48:48 +0900371
372 if (!options)
373 return 0;
374
375 while ((p = strsep(&options, ",")) != NULL) {
376 int token;
377 if (!*p)
378 continue;
379 /*
380 * Initialize args struct so we know whether arg was
381 * found; some options take optional arguments.
382 */
383 args[0].to = args[0].from = NULL;
384 token = match_token(p, f2fs_tokens, args);
385
386 switch (token) {
387 case Opt_gc_background:
388 name = match_strdup(&args[0]);
389
390 if (!name)
391 return -ENOMEM;
Jaegeuk Kim6aefd932015-10-05 11:02:54 -0700392 if (strlen(name) == 2 && !strncmp(name, "on", 2)) {
Namjae Jeon696c0182013-06-16 09:48:48 +0900393 set_opt(sbi, BG_GC);
Jaegeuk Kim6aefd932015-10-05 11:02:54 -0700394 clear_opt(sbi, FORCE_FG_GC);
395 } else if (strlen(name) == 3 && !strncmp(name, "off", 3)) {
Namjae Jeon696c0182013-06-16 09:48:48 +0900396 clear_opt(sbi, BG_GC);
Jaegeuk Kim6aefd932015-10-05 11:02:54 -0700397 clear_opt(sbi, FORCE_FG_GC);
398 } else if (strlen(name) == 4 && !strncmp(name, "sync", 4)) {
399 set_opt(sbi, BG_GC);
400 set_opt(sbi, FORCE_FG_GC);
401 } else {
Jaegeuk Kim52225952018-12-13 18:38:33 -0800402 kvfree(name);
Namjae Jeon696c0182013-06-16 09:48:48 +0900403 return -EINVAL;
404 }
Jaegeuk Kim52225952018-12-13 18:38:33 -0800405 kvfree(name);
Namjae Jeon696c0182013-06-16 09:48:48 +0900406 break;
407 case Opt_disable_roll_forward:
408 set_opt(sbi, DISABLE_ROLL_FORWARD);
409 break;
Jaegeuk Kim2d834bf2015-01-23 18:33:46 -0800410 case Opt_norecovery:
411 /* this option mounts f2fs with ro */
412 set_opt(sbi, DISABLE_ROLL_FORWARD);
413 if (!f2fs_readonly(sb))
414 return -EINVAL;
415 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900416 case Opt_discard:
Chao Yu7d20c8a2018-09-04 03:52:17 +0800417 set_opt(sbi, DISCARD);
Namjae Jeon696c0182013-06-16 09:48:48 +0900418 break;
Chao Yu64058be2016-07-03 22:05:14 +0800419 case Opt_nodiscard:
Chao Yu7beb01f2018-10-24 18:34:26 +0800420 if (f2fs_sb_has_blkzoned(sbi)) {
Damien Le Moal96ba2de2016-10-28 17:45:03 +0900421 f2fs_msg(sb, KERN_WARNING,
422 "discard is required for zoned block devices");
423 return -EINVAL;
424 }
Chao Yu64058be2016-07-03 22:05:14 +0800425 clear_opt(sbi, DISCARD);
Damien Le Moal487df612016-10-28 17:44:59 +0900426 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900427 case Opt_noheap:
428 set_opt(sbi, NOHEAP);
429 break;
Jaegeuk Kim7a20b8a2017-03-24 20:41:45 -0400430 case Opt_heap:
431 clear_opt(sbi, NOHEAP);
432 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900433#ifdef CONFIG_F2FS_FS_XATTR
Kelly Anderson4058c512013-10-07 11:36:20 +0900434 case Opt_user_xattr:
435 set_opt(sbi, XATTR_USER);
436 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900437 case Opt_nouser_xattr:
438 clear_opt(sbi, XATTR_USER);
439 break;
Jaegeuk Kim444c5802013-08-08 15:16:22 +0900440 case Opt_inline_xattr:
441 set_opt(sbi, INLINE_XATTR);
442 break;
Chao Yu23cf7212017-02-15 10:34:45 +0800443 case Opt_noinline_xattr:
444 clear_opt(sbi, INLINE_XATTR);
445 break;
Chao Yu6afc6622017-09-06 21:59:50 +0800446 case Opt_inline_xattr_size:
447 if (args->from && match_int(args, &arg))
448 return -EINVAL;
449 set_opt(sbi, INLINE_XATTR_SIZE);
Chao Yu63189b72018-03-08 14:22:56 +0800450 F2FS_OPTION(sbi).inline_xattr_size = arg;
Chao Yu6afc6622017-09-06 21:59:50 +0800451 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900452#else
Kelly Anderson4058c512013-10-07 11:36:20 +0900453 case Opt_user_xattr:
454 f2fs_msg(sb, KERN_INFO,
455 "user_xattr options not supported");
456 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900457 case Opt_nouser_xattr:
458 f2fs_msg(sb, KERN_INFO,
459 "nouser_xattr options not supported");
460 break;
Jaegeuk Kim444c5802013-08-08 15:16:22 +0900461 case Opt_inline_xattr:
462 f2fs_msg(sb, KERN_INFO,
463 "inline_xattr options not supported");
464 break;
Chao Yu23cf7212017-02-15 10:34:45 +0800465 case Opt_noinline_xattr:
466 f2fs_msg(sb, KERN_INFO,
467 "noinline_xattr options not supported");
468 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900469#endif
470#ifdef CONFIG_F2FS_FS_POSIX_ACL
Kelly Anderson4058c512013-10-07 11:36:20 +0900471 case Opt_acl:
472 set_opt(sbi, POSIX_ACL);
473 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900474 case Opt_noacl:
475 clear_opt(sbi, POSIX_ACL);
476 break;
477#else
Kelly Anderson4058c512013-10-07 11:36:20 +0900478 case Opt_acl:
479 f2fs_msg(sb, KERN_INFO, "acl options not supported");
480 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900481 case Opt_noacl:
482 f2fs_msg(sb, KERN_INFO, "noacl options not supported");
483 break;
484#endif
485 case Opt_active_logs:
486 if (args->from && match_int(args, &arg))
487 return -EINVAL;
488 if (arg != 2 && arg != 4 && arg != NR_CURSEG_TYPE)
489 return -EINVAL;
Chao Yu63189b72018-03-08 14:22:56 +0800490 F2FS_OPTION(sbi).active_logs = arg;
Namjae Jeon696c0182013-06-16 09:48:48 +0900491 break;
492 case Opt_disable_ext_identify:
493 set_opt(sbi, DISABLE_EXT_IDENTIFY);
494 break;
Huajun Li8274de72013-11-10 23:13:17 +0800495 case Opt_inline_data:
496 set_opt(sbi, INLINE_DATA);
497 break;
Chao Yu5efd3c62014-09-24 18:16:13 +0800498 case Opt_inline_dentry:
499 set_opt(sbi, INLINE_DENTRY);
500 break;
Chao Yu97c17942016-05-09 19:56:34 +0800501 case Opt_noinline_dentry:
502 clear_opt(sbi, INLINE_DENTRY);
503 break;
Jaegeuk Kim6b4afdd2014-04-02 15:34:36 +0900504 case Opt_flush_merge:
505 set_opt(sbi, FLUSH_MERGE);
506 break;
Jaegeuk Kim69e9e422016-05-20 22:39:20 -0700507 case Opt_noflush_merge:
508 clear_opt(sbi, FLUSH_MERGE);
509 break;
Jaegeuk Kim0f7b2ab2014-07-23 09:57:31 -0700510 case Opt_nobarrier:
511 set_opt(sbi, NOBARRIER);
512 break;
Jaegeuk Kimd5053a342014-10-30 22:47:03 -0700513 case Opt_fastboot:
514 set_opt(sbi, FASTBOOT);
515 break;
Chao Yu89672152015-02-05 17:55:51 +0800516 case Opt_extent_cache:
517 set_opt(sbi, EXTENT_CACHE);
518 break;
Jaegeuk Kim7daaea22015-06-25 17:43:04 -0700519 case Opt_noextent_cache:
520 clear_opt(sbi, EXTENT_CACHE);
521 break;
Wanpeng Li75342792015-03-24 10:20:27 +0800522 case Opt_noinline_data:
523 clear_opt(sbi, INLINE_DATA);
524 break;
Chao Yu343f40f2015-12-16 13:12:16 +0800525 case Opt_data_flush:
526 set_opt(sbi, DATA_FLUSH);
527 break;
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800528 case Opt_reserve_root:
529 if (args->from && match_int(args, &arg))
530 return -EINVAL;
531 if (test_opt(sbi, RESERVE_ROOT)) {
532 f2fs_msg(sb, KERN_INFO,
533 "Preserve previous reserve_root=%u",
Chao Yu63189b72018-03-08 14:22:56 +0800534 F2FS_OPTION(sbi).root_reserved_blocks);
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800535 } else {
Chao Yu63189b72018-03-08 14:22:56 +0800536 F2FS_OPTION(sbi).root_reserved_blocks = arg;
Jaegeuk Kim7e65be42017-12-27 15:05:52 -0800537 set_opt(sbi, RESERVE_ROOT);
538 }
539 break;
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800540 case Opt_resuid:
541 if (args->from && match_int(args, &arg))
542 return -EINVAL;
543 uid = make_kuid(current_user_ns(), arg);
544 if (!uid_valid(uid)) {
545 f2fs_msg(sb, KERN_ERR,
546 "Invalid uid value %d", arg);
547 return -EINVAL;
548 }
Chao Yu63189b72018-03-08 14:22:56 +0800549 F2FS_OPTION(sbi).s_resuid = uid;
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800550 break;
551 case Opt_resgid:
552 if (args->from && match_int(args, &arg))
553 return -EINVAL;
554 gid = make_kgid(current_user_ns(), arg);
555 if (!gid_valid(gid)) {
556 f2fs_msg(sb, KERN_ERR,
557 "Invalid gid value %d", arg);
558 return -EINVAL;
559 }
Chao Yu63189b72018-03-08 14:22:56 +0800560 F2FS_OPTION(sbi).s_resgid = gid;
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -0800561 break;
Jaegeuk Kim36abef42016-06-03 19:29:38 -0700562 case Opt_mode:
563 name = match_strdup(&args[0]);
564
565 if (!name)
566 return -ENOMEM;
567 if (strlen(name) == 8 &&
568 !strncmp(name, "adaptive", 8)) {
Chao Yu7beb01f2018-10-24 18:34:26 +0800569 if (f2fs_sb_has_blkzoned(sbi)) {
Damien Le Moal3adc57e2016-10-28 17:45:04 +0900570 f2fs_msg(sb, KERN_WARNING,
571 "adaptive mode is not allowed with "
572 "zoned block device feature");
Jaegeuk Kim52225952018-12-13 18:38:33 -0800573 kvfree(name);
Damien Le Moal3adc57e2016-10-28 17:45:04 +0900574 return -EINVAL;
575 }
Jaegeuk Kim52763a42016-06-13 09:47:48 -0700576 set_opt_mode(sbi, F2FS_MOUNT_ADAPTIVE);
Jaegeuk Kim36abef42016-06-03 19:29:38 -0700577 } else if (strlen(name) == 3 &&
578 !strncmp(name, "lfs", 3)) {
Jaegeuk Kim52763a42016-06-13 09:47:48 -0700579 set_opt_mode(sbi, F2FS_MOUNT_LFS);
Jaegeuk Kim36abef42016-06-03 19:29:38 -0700580 } else {
Jaegeuk Kim52225952018-12-13 18:38:33 -0800581 kvfree(name);
Jaegeuk Kim36abef42016-06-03 19:29:38 -0700582 return -EINVAL;
583 }
Jaegeuk Kim52225952018-12-13 18:38:33 -0800584 kvfree(name);
Jaegeuk Kim36abef42016-06-03 19:29:38 -0700585 break;
Jaegeuk Kimec915382016-12-21 17:09:19 -0800586 case Opt_io_size_bits:
587 if (args->from && match_int(args, &arg))
588 return -EINVAL;
Chao Yu6d52e132019-02-15 00:16:15 +0800589 if (arg <= 0 || arg > __ilog2_u32(BIO_MAX_PAGES)) {
Jaegeuk Kimec915382016-12-21 17:09:19 -0800590 f2fs_msg(sb, KERN_WARNING,
591 "Not support %d, larger than %d",
592 1 << arg, BIO_MAX_PAGES);
593 return -EINVAL;
594 }
Chao Yu63189b72018-03-08 14:22:56 +0800595 F2FS_OPTION(sbi).write_io_size_bits = arg;
Jaegeuk Kimec915382016-12-21 17:09:19 -0800596 break;
Chengguang Xu4cb037e2018-09-12 13:32:52 +0800597#ifdef CONFIG_F2FS_FAULT_INJECTION
Jaegeuk Kim73faec42016-04-29 15:34:32 -0700598 case Opt_fault_injection:
599 if (args->from && match_int(args, &arg))
600 return -EINVAL;
Chao Yud4945002018-08-08 17:36:41 +0800601 f2fs_build_fault_attr(sbi, arg, F2FS_ALL_FAULT_TYPE);
602 set_opt(sbi, FAULT_INJECTION);
Chao Yud4945002018-08-08 17:36:41 +0800603 break;
Chengguang Xu4cb037e2018-09-12 13:32:52 +0800604
Chao Yud4945002018-08-08 17:36:41 +0800605 case Opt_fault_type:
606 if (args->from && match_int(args, &arg))
607 return -EINVAL;
Chao Yud4945002018-08-08 17:36:41 +0800608 f2fs_build_fault_attr(sbi, 0, arg);
Kaixu Xia0cc0dec2017-01-27 09:35:37 +0800609 set_opt(sbi, FAULT_INJECTION);
Jaegeuk Kim73faec42016-04-29 15:34:32 -0700610 break;
Chengguang Xu4cb037e2018-09-12 13:32:52 +0800611#else
612 case Opt_fault_injection:
613 f2fs_msg(sb, KERN_INFO,
614 "fault_injection options not supported");
615 break;
616
617 case Opt_fault_type:
618 f2fs_msg(sb, KERN_INFO,
619 "fault_type options not supported");
620 break;
621#endif
Jaegeuk Kim6d94c742016-05-20 21:47:24 -0700622 case Opt_lazytime:
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800623 sb->s_flags |= SB_LAZYTIME;
Jaegeuk Kim6d94c742016-05-20 21:47:24 -0700624 break;
625 case Opt_nolazytime:
Linus Torvalds1751e8a2017-11-27 13:05:09 -0800626 sb->s_flags &= ~SB_LAZYTIME;
Jaegeuk Kim6d94c742016-05-20 21:47:24 -0700627 break;
Chao Yu0abd6752017-07-09 00:13:07 +0800628#ifdef CONFIG_QUOTA
Chao Yu4b2414d2017-08-08 10:54:31 +0800629 case Opt_quota:
Chao Yu0abd6752017-07-09 00:13:07 +0800630 case Opt_usrquota:
631 set_opt(sbi, USRQUOTA);
632 break;
633 case Opt_grpquota:
634 set_opt(sbi, GRPQUOTA);
635 break;
Chao Yu5c571322017-07-26 00:01:41 +0800636 case Opt_prjquota:
637 set_opt(sbi, PRJQUOTA);
638 break;
Chao Yu4b2414d2017-08-08 10:54:31 +0800639 case Opt_usrjquota:
640 ret = f2fs_set_qf_name(sb, USRQUOTA, &args[0]);
641 if (ret)
642 return ret;
643 break;
644 case Opt_grpjquota:
645 ret = f2fs_set_qf_name(sb, GRPQUOTA, &args[0]);
646 if (ret)
647 return ret;
648 break;
649 case Opt_prjjquota:
650 ret = f2fs_set_qf_name(sb, PRJQUOTA, &args[0]);
651 if (ret)
652 return ret;
653 break;
654 case Opt_offusrjquota:
655 ret = f2fs_clear_qf_name(sb, USRQUOTA);
656 if (ret)
657 return ret;
658 break;
659 case Opt_offgrpjquota:
660 ret = f2fs_clear_qf_name(sb, GRPQUOTA);
661 if (ret)
662 return ret;
663 break;
664 case Opt_offprjjquota:
665 ret = f2fs_clear_qf_name(sb, PRJQUOTA);
666 if (ret)
667 return ret;
668 break;
669 case Opt_jqfmt_vfsold:
Chao Yu63189b72018-03-08 14:22:56 +0800670 F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_OLD;
Chao Yu4b2414d2017-08-08 10:54:31 +0800671 break;
672 case Opt_jqfmt_vfsv0:
Chao Yu63189b72018-03-08 14:22:56 +0800673 F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V0;
Chao Yu4b2414d2017-08-08 10:54:31 +0800674 break;
675 case Opt_jqfmt_vfsv1:
Chao Yu63189b72018-03-08 14:22:56 +0800676 F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V1;
Chao Yu4b2414d2017-08-08 10:54:31 +0800677 break;
678 case Opt_noquota:
679 clear_opt(sbi, QUOTA);
680 clear_opt(sbi, USRQUOTA);
681 clear_opt(sbi, GRPQUOTA);
682 clear_opt(sbi, PRJQUOTA);
683 break;
Chao Yu0abd6752017-07-09 00:13:07 +0800684#else
Chao Yu4b2414d2017-08-08 10:54:31 +0800685 case Opt_quota:
Chao Yu0abd6752017-07-09 00:13:07 +0800686 case Opt_usrquota:
687 case Opt_grpquota:
Chao Yu5c571322017-07-26 00:01:41 +0800688 case Opt_prjquota:
Chao Yu4b2414d2017-08-08 10:54:31 +0800689 case Opt_usrjquota:
690 case Opt_grpjquota:
691 case Opt_prjjquota:
692 case Opt_offusrjquota:
693 case Opt_offgrpjquota:
694 case Opt_offprjjquota:
695 case Opt_jqfmt_vfsold:
696 case Opt_jqfmt_vfsv0:
697 case Opt_jqfmt_vfsv1:
698 case Opt_noquota:
Chao Yu0abd6752017-07-09 00:13:07 +0800699 f2fs_msg(sb, KERN_INFO,
700 "quota operations not supported");
701 break;
702#endif
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900703 case Opt_whint:
704 name = match_strdup(&args[0]);
705 if (!name)
706 return -ENOMEM;
707 if (strlen(name) == 10 &&
708 !strncmp(name, "user-based", 10)) {
Chao Yu63189b72018-03-08 14:22:56 +0800709 F2FS_OPTION(sbi).whint_mode = WHINT_MODE_USER;
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900710 } else if (strlen(name) == 3 &&
711 !strncmp(name, "off", 3)) {
Chao Yu63189b72018-03-08 14:22:56 +0800712 F2FS_OPTION(sbi).whint_mode = WHINT_MODE_OFF;
Hyunchul Leef2e703f2018-01-31 11:36:58 +0900713 } else if (strlen(name) == 8 &&
714 !strncmp(name, "fs-based", 8)) {
Chao Yu63189b72018-03-08 14:22:56 +0800715 F2FS_OPTION(sbi).whint_mode = WHINT_MODE_FS;
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900716 } else {
Jaegeuk Kim52225952018-12-13 18:38:33 -0800717 kvfree(name);
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900718 return -EINVAL;
719 }
Jaegeuk Kim52225952018-12-13 18:38:33 -0800720 kvfree(name);
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900721 break;
Jaegeuk Kim07939622018-02-18 08:50:49 -0800722 case Opt_alloc:
723 name = match_strdup(&args[0]);
724 if (!name)
725 return -ENOMEM;
726
727 if (strlen(name) == 7 &&
728 !strncmp(name, "default", 7)) {
Chao Yu63189b72018-03-08 14:22:56 +0800729 F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;
Jaegeuk Kim07939622018-02-18 08:50:49 -0800730 } else if (strlen(name) == 5 &&
731 !strncmp(name, "reuse", 5)) {
Chao Yu63189b72018-03-08 14:22:56 +0800732 F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
Jaegeuk Kim07939622018-02-18 08:50:49 -0800733 } else {
Jaegeuk Kim52225952018-12-13 18:38:33 -0800734 kvfree(name);
Jaegeuk Kim07939622018-02-18 08:50:49 -0800735 return -EINVAL;
736 }
Jaegeuk Kim52225952018-12-13 18:38:33 -0800737 kvfree(name);
Jaegeuk Kim07939622018-02-18 08:50:49 -0800738 break;
Junling Zheng93cf93f2018-03-07 12:07:49 +0800739 case Opt_fsync:
740 name = match_strdup(&args[0]);
741 if (!name)
742 return -ENOMEM;
743 if (strlen(name) == 5 &&
744 !strncmp(name, "posix", 5)) {
Chao Yu63189b72018-03-08 14:22:56 +0800745 F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;
Junling Zheng93cf93f2018-03-07 12:07:49 +0800746 } else if (strlen(name) == 6 &&
747 !strncmp(name, "strict", 6)) {
Chao Yu63189b72018-03-08 14:22:56 +0800748 F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_STRICT;
Jaegeuk Kimd6290812018-05-25 18:02:58 -0700749 } else if (strlen(name) == 9 &&
750 !strncmp(name, "nobarrier", 9)) {
751 F2FS_OPTION(sbi).fsync_mode =
752 FSYNC_MODE_NOBARRIER;
Junling Zheng93cf93f2018-03-07 12:07:49 +0800753 } else {
Jaegeuk Kim52225952018-12-13 18:38:33 -0800754 kvfree(name);
Junling Zheng93cf93f2018-03-07 12:07:49 +0800755 return -EINVAL;
756 }
Jaegeuk Kim52225952018-12-13 18:38:33 -0800757 kvfree(name);
Junling Zheng93cf93f2018-03-07 12:07:49 +0800758 break;
Sheng Yongff62af22018-03-15 18:51:42 +0800759 case Opt_test_dummy_encryption:
760#ifdef CONFIG_F2FS_FS_ENCRYPTION
Chao Yu7beb01f2018-10-24 18:34:26 +0800761 if (!f2fs_sb_has_encrypt(sbi)) {
Sheng Yongff62af22018-03-15 18:51:42 +0800762 f2fs_msg(sb, KERN_ERR, "Encrypt feature is off");
763 return -EINVAL;
764 }
765
766 F2FS_OPTION(sbi).test_dummy_encryption = true;
767 f2fs_msg(sb, KERN_INFO,
768 "Test dummy encryption mode enabled");
769#else
770 f2fs_msg(sb, KERN_INFO,
771 "Test dummy encryption mount option ignored");
772#endif
773 break;
Daniel Rosenberg43549942018-08-20 19:21:43 -0700774 case Opt_checkpoint:
775 name = match_strdup(&args[0]);
776 if (!name)
777 return -ENOMEM;
778
779 if (strlen(name) == 6 &&
780 !strncmp(name, "enable", 6)) {
781 clear_opt(sbi, DISABLE_CHECKPOINT);
782 } else if (strlen(name) == 7 &&
783 !strncmp(name, "disable", 7)) {
784 set_opt(sbi, DISABLE_CHECKPOINT);
785 } else {
Jaegeuk Kim52225952018-12-13 18:38:33 -0800786 kvfree(name);
Daniel Rosenberg43549942018-08-20 19:21:43 -0700787 return -EINVAL;
788 }
Jaegeuk Kim52225952018-12-13 18:38:33 -0800789 kvfree(name);
Daniel Rosenberg43549942018-08-20 19:21:43 -0700790 break;
Namjae Jeon696c0182013-06-16 09:48:48 +0900791 default:
792 f2fs_msg(sb, KERN_ERR,
793 "Unrecognized mount option \"%s\" or missing value",
794 p);
795 return -EINVAL;
796 }
797 }
Chao Yu4b2414d2017-08-08 10:54:31 +0800798#ifdef CONFIG_QUOTA
799 if (f2fs_check_quota_options(sbi))
800 return -EINVAL;
Sheng Yong00960c22018-07-24 20:17:52 +0800801#else
Chao Yu7beb01f2018-10-24 18:34:26 +0800802 if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sbi->sb)) {
Sheng Yong00960c22018-07-24 20:17:52 +0800803 f2fs_msg(sbi->sb, KERN_INFO,
804 "Filesystem with quota feature cannot be mounted RDWR "
805 "without CONFIG_QUOTA");
806 return -EINVAL;
807 }
Chao Yu7beb01f2018-10-24 18:34:26 +0800808 if (f2fs_sb_has_project_quota(sbi) && !f2fs_readonly(sbi->sb)) {
Chao Yu4ddc1b22018-07-26 07:19:48 +0800809 f2fs_msg(sb, KERN_ERR,
810 "Filesystem with project quota feature cannot be "
811 "mounted RDWR without CONFIG_QUOTA");
812 return -EINVAL;
813 }
Chao Yu4b2414d2017-08-08 10:54:31 +0800814#endif
Jaegeuk Kimec915382016-12-21 17:09:19 -0800815
816 if (F2FS_IO_SIZE_BITS(sbi) && !test_opt(sbi, LFS)) {
817 f2fs_msg(sb, KERN_ERR,
818 "Should set mode=lfs with %uKB-sized IO",
819 F2FS_IO_SIZE_KB(sbi));
820 return -EINVAL;
821 }
Chao Yu6afc6622017-09-06 21:59:50 +0800822
823 if (test_opt(sbi, INLINE_XATTR_SIZE)) {
Chao Yu7beb01f2018-10-24 18:34:26 +0800824 if (!f2fs_sb_has_extra_attr(sbi) ||
825 !f2fs_sb_has_flexible_inline_xattr(sbi)) {
Chao Yu4d817ae2018-01-27 17:29:48 +0800826 f2fs_msg(sb, KERN_ERR,
827 "extra_attr or flexible_inline_xattr "
828 "feature is off");
829 return -EINVAL;
830 }
Chao Yu6afc6622017-09-06 21:59:50 +0800831 if (!test_opt(sbi, INLINE_XATTR)) {
832 f2fs_msg(sb, KERN_ERR,
833 "inline_xattr_size option should be "
834 "set with inline_xattr option");
835 return -EINVAL;
836 }
Chao Yu500e0b22019-02-15 00:08:25 +0800837 if (F2FS_OPTION(sbi).inline_xattr_size <
838 sizeof(struct f2fs_xattr_header) / sizeof(__le32) ||
839 F2FS_OPTION(sbi).inline_xattr_size >
840 DEF_ADDRS_PER_INODE -
841 F2FS_TOTAL_EXTRA_ATTR_SIZE / sizeof(__le32) -
842 DEF_INLINE_RESERVED_SIZE -
843 MIN_INLINE_DENTRY_SIZE / sizeof(__le32)) {
Chao Yu6afc6622017-09-06 21:59:50 +0800844 f2fs_msg(sb, KERN_ERR,
845 "inline xattr size is out of range");
846 return -EINVAL;
847 }
848 }
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900849
Daniel Rosenberg43549942018-08-20 19:21:43 -0700850 if (test_opt(sbi, DISABLE_CHECKPOINT) && test_opt(sbi, LFS)) {
851 f2fs_msg(sb, KERN_ERR,
852 "LFS not compatible with checkpoint=disable\n");
853 return -EINVAL;
854 }
855
Hyunchul Lee0cdd3192018-01-31 11:36:57 +0900856 /* Not pass down write hints if the number of active logs is lesser
857 * than NR_CURSEG_TYPE.
858 */
Chao Yu63189b72018-03-08 14:22:56 +0800859 if (F2FS_OPTION(sbi).active_logs != NR_CURSEG_TYPE)
860 F2FS_OPTION(sbi).whint_mode = WHINT_MODE_OFF;
Namjae Jeon696c0182013-06-16 09:48:48 +0900861 return 0;
862}
863
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900864static struct inode *f2fs_alloc_inode(struct super_block *sb)
865{
866 struct f2fs_inode_info *fi;
867
Chao Yua0acdfe2013-12-05 09:54:00 +0800868 fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_F2FS_ZERO);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900869 if (!fi)
870 return NULL;
871
872 init_once((void *) fi);
873
Masanari Iida434720f2013-03-19 08:03:35 +0900874 /* Initialize f2fs-specific inode info */
Jaegeuk Kim204706c2016-12-02 15:11:32 -0800875 atomic_set(&fi->dirty_pages, 0);
Jaegeuk Kimd928bfb2014-03-20 19:10:08 +0900876 init_rwsem(&fi->i_sem);
Chao Yu2710fd72015-12-15 13:30:45 +0800877 INIT_LIST_HEAD(&fi->dirty_list);
Jaegeuk Kim0f18b462016-05-20 11:10:10 -0700878 INIT_LIST_HEAD(&fi->gdirty_list);
Jaegeuk Kim57864ae2017-10-18 19:05:57 -0700879 INIT_LIST_HEAD(&fi->inmem_ilist);
Jaegeuk Kim88b88a62014-10-06 17:39:50 -0700880 INIT_LIST_HEAD(&fi->inmem_pages);
881 mutex_init(&fi->inmem_lock);
Chao Yub2532c62018-04-24 10:55:28 +0800882 init_rwsem(&fi->i_gc_rwsem[READ]);
883 init_rwsem(&fi->i_gc_rwsem[WRITE]);
Qiuyang Sun5a3a2d82017-05-18 11:06:45 +0800884 init_rwsem(&fi->i_mmap_sem);
Yunlei He27161f12017-09-07 10:40:54 +0800885 init_rwsem(&fi->i_xattr_sem);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900886
Jaegeuk Kimab9fa662014-02-27 20:09:05 +0900887 /* Will be used by directory only */
888 fi->i_dir_level = F2FS_SB(sb)->dir_level;
Chao Yuf2470372017-07-19 00:19:05 +0800889
Jaegeuk Kimaff063e2012-11-02 17:07:47 +0900890 return &fi->vfs_inode;
891}
892
Jaegeuk Kim531ad7d2013-04-30 11:33:27 +0900893static int f2fs_drop_inode(struct inode *inode)
894{
Hou Pengyangb8d96a32017-02-27 13:02:58 +0000895 int ret;
Jaegeuk Kim531ad7d2013-04-30 11:33:27 +0900896 /*
897 * This is to avoid a deadlock condition like below.
898 * writeback_single_inode(inode)
899 * - f2fs_write_data_page
900 * - f2fs_gc -> iput -> evict
901 * - inode_wait_for_writeback(inode)
902 */
Jaegeuk Kim0f18b462016-05-20 11:10:10 -0700903 if ((!inode_unhashed(inode) && inode->i_state & I_SYNC)) {
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -0700904 if (!inode->i_nlink && !is_bad_inode(inode)) {
Jaegeuk Kim3e72f722015-06-19 17:53:26 -0700905 /* to avoid evict_inode call simultaneously */
906 atomic_inc(&inode->i_count);
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -0700907 spin_unlock(&inode->i_lock);
908
909 /* some remained atomic pages should discarded */
910 if (f2fs_is_atomic_file(inode))
Chao Yu4d57b862018-05-30 00:20:41 +0800911 f2fs_drop_inmem_pages(inode);
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -0700912
Jaegeuk Kim3e72f722015-06-19 17:53:26 -0700913 /* should remain fi->extent_tree for writepage */
914 f2fs_destroy_extent_node(inode);
915
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -0700916 sb_start_intwrite(inode->i_sb);
Jaegeuk Kimfc9581c2016-05-20 09:22:03 -0700917 f2fs_i_size_write(inode, 0);
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -0700918
zhenglianga0770e12019-03-04 09:32:25 +0800919 f2fs_submit_merged_write_cond(F2FS_I_SB(inode),
920 inode, NULL, 0, DATA);
921 truncate_inode_pages_final(inode->i_mapping);
922
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -0700923 if (F2FS_HAS_BLOCKS(inode))
Jaegeuk Kim9a449e92016-06-02 13:49:38 -0700924 f2fs_truncate(inode);
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -0700925
926 sb_end_intwrite(inode->i_sb);
927
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -0700928 spin_lock(&inode->i_lock);
Jaegeuk Kim3e72f722015-06-19 17:53:26 -0700929 atomic_dec(&inode->i_count);
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -0700930 }
Hou Pengyangb8d96a32017-02-27 13:02:58 +0000931 trace_f2fs_drop_inode(inode, 0);
Jaegeuk Kim531ad7d2013-04-30 11:33:27 +0900932 return 0;
Jaegeuk Kim06e1bc02015-05-13 14:35:14 -0700933 }
Hou Pengyangb8d96a32017-02-27 13:02:58 +0000934 ret = generic_drop_inode(inode);
935 trace_f2fs_drop_inode(inode, ret);
936 return ret;
Jaegeuk Kim531ad7d2013-04-30 11:33:27 +0900937}
938
Jaegeuk Kim7c457292016-10-14 11:51:23 -0700939int f2fs_inode_dirtied(struct inode *inode, bool sync)
Jaegeuk Kimb56ab832016-06-30 19:09:37 -0700940{
941 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Jaegeuk Kim7c457292016-10-14 11:51:23 -0700942 int ret = 0;
Jaegeuk Kimb56ab832016-06-30 19:09:37 -0700943
944 spin_lock(&sbi->inode_lock[DIRTY_META]);
945 if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
Jaegeuk Kim7c457292016-10-14 11:51:23 -0700946 ret = 1;
947 } else {
948 set_inode_flag(inode, FI_DIRTY_INODE);
949 stat_inc_dirty_inode(sbi, DIRTY_META);
Jaegeuk Kimb56ab832016-06-30 19:09:37 -0700950 }
Jaegeuk Kim7c457292016-10-14 11:51:23 -0700951 if (sync && list_empty(&F2FS_I(inode)->gdirty_list)) {
952 list_add_tail(&F2FS_I(inode)->gdirty_list,
Jaegeuk Kimb56ab832016-06-30 19:09:37 -0700953 &sbi->inode_list[DIRTY_META]);
Jaegeuk Kim7c457292016-10-14 11:51:23 -0700954 inc_page_count(sbi, F2FS_DIRTY_IMETA);
955 }
Jaegeuk Kimb56ab832016-06-30 19:09:37 -0700956 spin_unlock(&sbi->inode_lock[DIRTY_META]);
Jaegeuk Kim7c457292016-10-14 11:51:23 -0700957 return ret;
Jaegeuk Kimb56ab832016-06-30 19:09:37 -0700958}
959
960void f2fs_inode_synced(struct inode *inode)
961{
962 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
963
964 spin_lock(&sbi->inode_lock[DIRTY_META]);
965 if (!is_inode_flag_set(inode, FI_DIRTY_INODE)) {
966 spin_unlock(&sbi->inode_lock[DIRTY_META]);
967 return;
968 }
Jaegeuk Kim7c457292016-10-14 11:51:23 -0700969 if (!list_empty(&F2FS_I(inode)->gdirty_list)) {
970 list_del_init(&F2FS_I(inode)->gdirty_list);
971 dec_page_count(sbi, F2FS_DIRTY_IMETA);
972 }
Jaegeuk Kimb56ab832016-06-30 19:09:37 -0700973 clear_inode_flag(inode, FI_DIRTY_INODE);
974 clear_inode_flag(inode, FI_AUTO_RECOVER);
Jaegeuk Kimb56ab832016-06-30 19:09:37 -0700975 stat_dec_dirty_inode(F2FS_I_SB(inode), DIRTY_META);
976 spin_unlock(&sbi->inode_lock[DIRTY_META]);
977}
978
Jaegeuk Kimb3783872013-06-10 09:17:01 +0900979/*
980 * f2fs_dirty_inode() is called from __mark_inode_dirty()
981 *
982 * We should call set_dirty_inode to write the dirty inode through write_inode.
983 */
984static void f2fs_dirty_inode(struct inode *inode, int flags)
985{
Jaegeuk Kim0f18b462016-05-20 11:10:10 -0700986 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
987
988 if (inode->i_ino == F2FS_NODE_INO(sbi) ||
989 inode->i_ino == F2FS_META_INO(sbi))
990 return;
991
Jaegeuk Kim6d94c742016-05-20 21:47:24 -0700992 if (flags == I_DIRTY_TIME)
993 return;
994
Jaegeuk Kim26de9b12016-05-20 20:42:37 -0700995 if (is_inode_flag_set(inode, FI_AUTO_RECOVER))
996 clear_inode_flag(inode, FI_AUTO_RECOVER);
997
Jaegeuk Kim7c457292016-10-14 11:51:23 -0700998 f2fs_inode_dirtied(inode, false);
Jaegeuk Kimb3783872013-06-10 09:17:01 +0900999}
1000
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001001static void f2fs_i_callback(struct rcu_head *head)
1002{
1003 struct inode *inode = container_of(head, struct inode, i_rcu);
1004 kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode));
1005}
1006
Jaegeuk Kim25ca9232012-11-28 16:12:41 +09001007static void f2fs_destroy_inode(struct inode *inode)
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001008{
1009 call_rcu(&inode->i_rcu, f2fs_i_callback);
1010}
1011
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07001012static void destroy_percpu_info(struct f2fs_sb_info *sbi)
1013{
Jaegeuk Kim41382ec2016-05-16 11:06:50 -07001014 percpu_counter_destroy(&sbi->alloc_valid_block_count);
Jaegeuk Kim513c5f32016-05-16 11:42:32 -07001015 percpu_counter_destroy(&sbi->total_valid_inode_count);
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07001016}
1017
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07001018static void destroy_device_list(struct f2fs_sb_info *sbi)
1019{
1020 int i;
1021
1022 for (i = 0; i < sbi->s_ndevs; i++) {
1023 blkdev_put(FDEV(i).bdev, FMODE_EXCL);
1024#ifdef CONFIG_BLK_DEV_ZONED
Jaegeuk Kim52225952018-12-13 18:38:33 -08001025 kvfree(FDEV(i).blkz_type);
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07001026#endif
1027 }
Jaegeuk Kim52225952018-12-13 18:38:33 -08001028 kvfree(sbi->devs);
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07001029}
1030
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001031static void f2fs_put_super(struct super_block *sb)
1032{
1033 struct f2fs_sb_info *sbi = F2FS_SB(sb);
Chao Yua3981012017-06-14 17:39:46 +08001034 int i;
Chao Yucf5c7592017-10-04 09:08:37 +08001035 bool dropped;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001036
Chao Yu0abd6752017-07-09 00:13:07 +08001037 f2fs_quota_off_umount(sb);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001038
Jaegeuk Kim2658e502015-06-19 12:01:21 -07001039 /* prevent remaining shrinker jobs */
1040 mutex_lock(&sbi->umount_mutex);
1041
Jaegeuk Kim85dc2f22015-01-14 17:41:41 -08001042 /*
1043 * We don't need to do checkpoint when superblock is clean.
1044 * But, the previous checkpoint was not done by umount, it needs to do
1045 * clean checkpoint again.
1046 */
Daniel Rosenberg43549942018-08-20 19:21:43 -07001047 if ((is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||
1048 !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG))) {
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -07001049 struct cp_control cpc = {
1050 .reason = CP_UMOUNT,
1051 };
Chao Yu4d57b862018-05-30 00:20:41 +08001052 f2fs_write_checkpoint(sbi, &cpc);
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -07001053 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001054
Jaegeuk Kim4e6a8d92016-12-29 14:07:53 -08001055 /* be sure to wait for any on-going discard commands */
Jaegeuk Kim03f2c022019-01-14 10:42:11 -08001056 dropped = f2fs_issue_discard_timeout(sbi);
Jaegeuk Kim4e6a8d92016-12-29 14:07:53 -08001057
Chao Yu7d20c8a2018-09-04 03:52:17 +08001058 if ((f2fs_hw_support_discard(sbi) || f2fs_hw_should_discard(sbi)) &&
1059 !sbi->discard_blks && !dropped) {
Chao Yu1f43e2a2017-04-28 13:56:08 +08001060 struct cp_control cpc = {
1061 .reason = CP_UMOUNT | CP_TRIMMED,
1062 };
Chao Yu4d57b862018-05-30 00:20:41 +08001063 f2fs_write_checkpoint(sbi, &cpc);
Chao Yu1f43e2a2017-04-28 13:56:08 +08001064 }
1065
Jaegeuk Kimcf779ca2014-08-11 18:37:46 -07001066 /*
1067 * normally superblock is clean, so we need to release this.
1068 * In addition, EIO will skip do checkpoint, we need this as well.
1069 */
Chao Yu4d57b862018-05-30 00:20:41 +08001070 f2fs_release_ino_entry(sbi, true);
Jaegeuk Kim6f12ac22014-08-19 09:48:22 -07001071
Jaegeuk Kim2658e502015-06-19 12:01:21 -07001072 f2fs_leave_shrinker(sbi);
1073 mutex_unlock(&sbi->umount_mutex);
1074
Jaegeuk Kim17c19122016-01-29 08:57:59 -08001075 /* our cp_error case, we can wait for any writeback page */
Jaegeuk Kimb9109b02017-05-10 11:28:38 -07001076 f2fs_flush_merged_writes(sbi);
Jaegeuk Kim17c19122016-01-29 08:57:59 -08001077
Chao Yu50fa53e2018-08-02 23:03:19 +08001078 f2fs_wait_on_all_pages_writeback(sbi);
1079
1080 f2fs_bug_on(sbi, sbi->fsync_node_num);
1081
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001082 iput(sbi->node_inode);
Jaegeuk Kim7c77bf72019-01-01 00:11:30 -08001083 sbi->node_inode = NULL;
1084
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001085 iput(sbi->meta_inode);
Jaegeuk Kim7c77bf72019-01-01 00:11:30 -08001086 sbi->meta_inode = NULL;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001087
Sahitya Tummala60aa4d52018-12-26 11:20:29 +05301088 /*
1089 * iput() can update stat information, if f2fs_write_checkpoint()
1090 * above failed with error.
1091 */
1092 f2fs_destroy_stats(sbi);
1093
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001094 /* destroy f2fs internal modules */
Chao Yu4d57b862018-05-30 00:20:41 +08001095 f2fs_destroy_node_manager(sbi);
1096 f2fs_destroy_segment_manager(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001097
Jaegeuk Kim52225952018-12-13 18:38:33 -08001098 kvfree(sbi->ckpt);
Chao Yua3981012017-06-14 17:39:46 +08001099
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -07001100 f2fs_unregister_sysfs(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001101
1102 sb->s_fs_info = NULL;
Keith Mok43b65732016-03-02 12:04:24 -08001103 if (sbi->s_chksum_driver)
1104 crypto_free_shash(sbi->s_chksum_driver);
Jaegeuk Kim52225952018-12-13 18:38:33 -08001105 kvfree(sbi->raw_super);
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07001106
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07001107 destroy_device_list(sbi);
Chao Yub6895e82017-02-27 18:43:12 +08001108 mempool_destroy(sbi->write_io_dummy);
Chao Yu4b2414d2017-08-08 10:54:31 +08001109#ifdef CONFIG_QUOTA
1110 for (i = 0; i < MAXQUOTAS; i++)
Jaegeuk Kim52225952018-12-13 18:38:33 -08001111 kvfree(F2FS_OPTION(sbi).s_qf_names[i]);
Chao Yu4b2414d2017-08-08 10:54:31 +08001112#endif
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07001113 destroy_percpu_info(sbi);
Jaegeuk Kima912b542017-05-10 11:18:25 -07001114 for (i = 0; i < NR_PAGE_TYPE; i++)
Jaegeuk Kim52225952018-12-13 18:38:33 -08001115 kvfree(sbi->write_io[i]);
1116 kvfree(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001117}
1118
1119int f2fs_sync_fs(struct super_block *sb, int sync)
1120{
1121 struct f2fs_sb_info *sbi = F2FS_SB(sb);
Chao Yuc34f42e2015-12-23 17:50:30 +08001122 int err = 0;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001123
Jaegeuk Kim1f227a32017-10-23 23:48:49 +02001124 if (unlikely(f2fs_cp_error(sbi)))
1125 return 0;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001126 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
1127 return 0;
Jaegeuk Kim1f227a32017-10-23 23:48:49 +02001128
Namjae Jeona2a4a7e2013-04-20 01:28:40 +09001129 trace_f2fs_sync_fs(sb, sync);
1130
Chao Yu4b2414d2017-08-08 10:54:31 +08001131 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
1132 return -EAGAIN;
1133
Jaegeuk Kimb7473752013-04-01 08:32:21 +09001134 if (sync) {
Jaegeuk Kimd5053a342014-10-30 22:47:03 -07001135 struct cp_control cpc;
1136
Jaegeuk Kim119ee912015-01-29 11:45:33 -08001137 cpc.reason = __get_cp_reason(sbi);
1138
Jaegeuk Kimb7473752013-04-01 08:32:21 +09001139 mutex_lock(&sbi->gc_mutex);
Chao Yu4d57b862018-05-30 00:20:41 +08001140 err = f2fs_write_checkpoint(sbi, &cpc);
Jaegeuk Kimb7473752013-04-01 08:32:21 +09001141 mutex_unlock(&sbi->gc_mutex);
Jaegeuk Kimb7473752013-04-01 08:32:21 +09001142 }
Jaegeuk Kim05ca3632015-04-23 14:38:15 -07001143 f2fs_trace_ios(NULL, 1);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001144
Chao Yuc34f42e2015-12-23 17:50:30 +08001145 return err;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001146}
1147
Changman Leed6212a52013-01-29 18:30:07 +09001148static int f2fs_freeze(struct super_block *sb)
1149{
Jaegeuk Kim77888c12013-05-20 20:28:47 +09001150 if (f2fs_readonly(sb))
Changman Leed6212a52013-01-29 18:30:07 +09001151 return 0;
1152
Jaegeuk Kimb4b9d342016-11-04 14:59:15 -07001153 /* IO error happened before */
1154 if (unlikely(f2fs_cp_error(F2FS_SB(sb))))
1155 return -EIO;
1156
1157 /* must be clean, since sync_filesystem() was already called */
1158 if (is_sbi_flag_set(F2FS_SB(sb), SBI_IS_DIRTY))
1159 return -EINVAL;
1160 return 0;
Changman Leed6212a52013-01-29 18:30:07 +09001161}
1162
1163static int f2fs_unfreeze(struct super_block *sb)
1164{
1165 return 0;
1166}
1167
Chao Yuddc34e32017-07-29 00:32:53 +08001168#ifdef CONFIG_QUOTA
1169static int f2fs_statfs_project(struct super_block *sb,
1170 kprojid_t projid, struct kstatfs *buf)
1171{
1172 struct kqid qid;
1173 struct dquot *dquot;
1174 u64 limit;
1175 u64 curblock;
1176
1177 qid = make_kqid_projid(projid);
1178 dquot = dqget(sb, qid);
1179 if (IS_ERR(dquot))
1180 return PTR_ERR(dquot);
Sheng Yong955ac6e2018-07-24 20:17:53 +08001181 spin_lock(&dquot->dq_dqb_lock);
Chao Yuddc34e32017-07-29 00:32:53 +08001182
1183 limit = (dquot->dq_dqb.dqb_bsoftlimit ?
1184 dquot->dq_dqb.dqb_bsoftlimit :
1185 dquot->dq_dqb.dqb_bhardlimit) >> sb->s_blocksize_bits;
1186 if (limit && buf->f_blocks > limit) {
1187 curblock = dquot->dq_dqb.dqb_curspace >> sb->s_blocksize_bits;
1188 buf->f_blocks = limit;
1189 buf->f_bfree = buf->f_bavail =
1190 (buf->f_blocks > curblock) ?
1191 (buf->f_blocks - curblock) : 0;
1192 }
1193
1194 limit = dquot->dq_dqb.dqb_isoftlimit ?
1195 dquot->dq_dqb.dqb_isoftlimit :
1196 dquot->dq_dqb.dqb_ihardlimit;
1197 if (limit && buf->f_files > limit) {
1198 buf->f_files = limit;
1199 buf->f_ffree =
1200 (buf->f_files > dquot->dq_dqb.dqb_curinodes) ?
1201 (buf->f_files - dquot->dq_dqb.dqb_curinodes) : 0;
1202 }
1203
Sheng Yong955ac6e2018-07-24 20:17:53 +08001204 spin_unlock(&dquot->dq_dqb_lock);
Chao Yuddc34e32017-07-29 00:32:53 +08001205 dqput(dquot);
1206 return 0;
1207}
1208#endif
1209
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001210static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)
1211{
1212 struct super_block *sb = dentry->d_sb;
1213 struct f2fs_sb_info *sbi = F2FS_SB(sb);
1214 u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
Jaegeuk Kimf66c0272018-01-03 10:55:07 -08001215 block_t total_count, user_block_count, start_count;
Jaegeuk Kim0cc091d2017-06-21 20:55:55 -07001216 u64 avail_node_count;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001217
1218 total_count = le64_to_cpu(sbi->raw_super->block_count);
1219 user_block_count = sbi->user_block_count;
1220 start_count = le32_to_cpu(sbi->raw_super->segment0_blkaddr);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001221 buf->f_type = F2FS_SUPER_MAGIC;
1222 buf->f_bsize = sbi->blocksize;
1223
1224 buf->f_blocks = total_count - start_count;
Jaegeuk Kimf66c0272018-01-03 10:55:07 -08001225 buf->f_bfree = user_block_count - valid_user_blocks(sbi) -
Yunlong Song80d42142017-10-27 20:45:05 +08001226 sbi->current_reserved_blocks;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001227 if (unlikely(buf->f_bfree <= sbi->unusable_block_count))
1228 buf->f_bfree = 0;
1229 else
1230 buf->f_bfree -= sbi->unusable_block_count;
1231
Chao Yu63189b72018-03-08 14:22:56 +08001232 if (buf->f_bfree > F2FS_OPTION(sbi).root_reserved_blocks)
1233 buf->f_bavail = buf->f_bfree -
1234 F2FS_OPTION(sbi).root_reserved_blocks;
Jaegeuk Kim7e65be42017-12-27 15:05:52 -08001235 else
1236 buf->f_bavail = 0;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001237
Chao Yu292c196a2017-11-16 16:59:14 +08001238 avail_node_count = sbi->total_node_count - sbi->nquota_files -
1239 F2FS_RESERVED_NODE_NUM;
Jaegeuk Kim0cc091d2017-06-21 20:55:55 -07001240
1241 if (avail_node_count > user_block_count) {
1242 buf->f_files = user_block_count;
1243 buf->f_ffree = buf->f_bavail;
1244 } else {
1245 buf->f_files = avail_node_count;
1246 buf->f_ffree = min(avail_node_count - valid_node_count(sbi),
1247 buf->f_bavail);
1248 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001249
Jaegeuk Kim5a20d332013-03-03 13:58:05 +09001250 buf->f_namelen = F2FS_NAME_LEN;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001251 buf->f_fsid.val[0] = (u32)id;
1252 buf->f_fsid.val[1] = (u32)(id >> 32);
1253
Chao Yuddc34e32017-07-29 00:32:53 +08001254#ifdef CONFIG_QUOTA
1255 if (is_inode_flag_set(dentry->d_inode, FI_PROJ_INHERIT) &&
1256 sb_has_quota_limits_enabled(sb, PRJQUOTA)) {
1257 f2fs_statfs_project(sb, F2FS_I(dentry->d_inode)->i_projid, buf);
1258 }
1259#endif
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001260 return 0;
1261}
1262
Chao Yu4b2414d2017-08-08 10:54:31 +08001263static inline void f2fs_show_quota_options(struct seq_file *seq,
1264 struct super_block *sb)
1265{
1266#ifdef CONFIG_QUOTA
1267 struct f2fs_sb_info *sbi = F2FS_SB(sb);
1268
Chao Yu63189b72018-03-08 14:22:56 +08001269 if (F2FS_OPTION(sbi).s_jquota_fmt) {
Chao Yu4b2414d2017-08-08 10:54:31 +08001270 char *fmtname = "";
1271
Chao Yu63189b72018-03-08 14:22:56 +08001272 switch (F2FS_OPTION(sbi).s_jquota_fmt) {
Chao Yu4b2414d2017-08-08 10:54:31 +08001273 case QFMT_VFS_OLD:
1274 fmtname = "vfsold";
1275 break;
1276 case QFMT_VFS_V0:
1277 fmtname = "vfsv0";
1278 break;
1279 case QFMT_VFS_V1:
1280 fmtname = "vfsv1";
1281 break;
1282 }
1283 seq_printf(seq, ",jqfmt=%s", fmtname);
1284 }
1285
Chao Yu63189b72018-03-08 14:22:56 +08001286 if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA])
1287 seq_show_option(seq, "usrjquota",
1288 F2FS_OPTION(sbi).s_qf_names[USRQUOTA]);
Chao Yu4b2414d2017-08-08 10:54:31 +08001289
Chao Yu63189b72018-03-08 14:22:56 +08001290 if (F2FS_OPTION(sbi).s_qf_names[GRPQUOTA])
1291 seq_show_option(seq, "grpjquota",
1292 F2FS_OPTION(sbi).s_qf_names[GRPQUOTA]);
Chao Yu4b2414d2017-08-08 10:54:31 +08001293
Chao Yu63189b72018-03-08 14:22:56 +08001294 if (F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])
1295 seq_show_option(seq, "prjjquota",
1296 F2FS_OPTION(sbi).s_qf_names[PRJQUOTA]);
Chao Yu4b2414d2017-08-08 10:54:31 +08001297#endif
1298}
1299
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001300static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
1301{
1302 struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb);
1303
Jaegeuk Kim6aefd932015-10-05 11:02:54 -07001304 if (!f2fs_readonly(sbi->sb) && test_opt(sbi, BG_GC)) {
1305 if (test_opt(sbi, FORCE_FG_GC))
1306 seq_printf(seq, ",background_gc=%s", "sync");
1307 else
1308 seq_printf(seq, ",background_gc=%s", "on");
1309 } else {
Namjae Jeon696c0182013-06-16 09:48:48 +09001310 seq_printf(seq, ",background_gc=%s", "off");
Jaegeuk Kim6aefd932015-10-05 11:02:54 -07001311 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001312 if (test_opt(sbi, DISABLE_ROLL_FORWARD))
1313 seq_puts(seq, ",disable_roll_forward");
1314 if (test_opt(sbi, DISCARD))
1315 seq_puts(seq, ",discard");
1316 if (test_opt(sbi, NOHEAP))
Jaegeuk Kim7a20b8a2017-03-24 20:41:45 -04001317 seq_puts(seq, ",no_heap");
1318 else
1319 seq_puts(seq, ",heap");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001320#ifdef CONFIG_F2FS_FS_XATTR
1321 if (test_opt(sbi, XATTR_USER))
1322 seq_puts(seq, ",user_xattr");
1323 else
1324 seq_puts(seq, ",nouser_xattr");
Jaegeuk Kim444c5802013-08-08 15:16:22 +09001325 if (test_opt(sbi, INLINE_XATTR))
1326 seq_puts(seq, ",inline_xattr");
Chao Yu23cf7212017-02-15 10:34:45 +08001327 else
1328 seq_puts(seq, ",noinline_xattr");
Chao Yu6afc6622017-09-06 21:59:50 +08001329 if (test_opt(sbi, INLINE_XATTR_SIZE))
1330 seq_printf(seq, ",inline_xattr_size=%u",
Chao Yu63189b72018-03-08 14:22:56 +08001331 F2FS_OPTION(sbi).inline_xattr_size);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001332#endif
1333#ifdef CONFIG_F2FS_FS_POSIX_ACL
1334 if (test_opt(sbi, POSIX_ACL))
1335 seq_puts(seq, ",acl");
1336 else
1337 seq_puts(seq, ",noacl");
1338#endif
1339 if (test_opt(sbi, DISABLE_EXT_IDENTIFY))
Alejandro Martinez Ruizaa435072013-01-25 19:08:59 +01001340 seq_puts(seq, ",disable_ext_identify");
Huajun Li8274de72013-11-10 23:13:17 +08001341 if (test_opt(sbi, INLINE_DATA))
1342 seq_puts(seq, ",inline_data");
Wanpeng Li75342792015-03-24 10:20:27 +08001343 else
1344 seq_puts(seq, ",noinline_data");
Chao Yu5efd3c62014-09-24 18:16:13 +08001345 if (test_opt(sbi, INLINE_DENTRY))
1346 seq_puts(seq, ",inline_dentry");
Chao Yu97c17942016-05-09 19:56:34 +08001347 else
1348 seq_puts(seq, ",noinline_dentry");
Gu Zhengb270ad62014-04-11 17:49:55 +08001349 if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE))
Jaegeuk Kim6b4afdd2014-04-02 15:34:36 +09001350 seq_puts(seq, ",flush_merge");
Jaegeuk Kim0f7b2ab2014-07-23 09:57:31 -07001351 if (test_opt(sbi, NOBARRIER))
1352 seq_puts(seq, ",nobarrier");
Jaegeuk Kimd5053a342014-10-30 22:47:03 -07001353 if (test_opt(sbi, FASTBOOT))
1354 seq_puts(seq, ",fastboot");
Chao Yu89672152015-02-05 17:55:51 +08001355 if (test_opt(sbi, EXTENT_CACHE))
1356 seq_puts(seq, ",extent_cache");
Jaegeuk Kim7daaea22015-06-25 17:43:04 -07001357 else
1358 seq_puts(seq, ",noextent_cache");
Chao Yu343f40f2015-12-16 13:12:16 +08001359 if (test_opt(sbi, DATA_FLUSH))
1360 seq_puts(seq, ",data_flush");
Jaegeuk Kim36abef42016-06-03 19:29:38 -07001361
1362 seq_puts(seq, ",mode=");
1363 if (test_opt(sbi, ADAPTIVE))
1364 seq_puts(seq, "adaptive");
1365 else if (test_opt(sbi, LFS))
1366 seq_puts(seq, "lfs");
Chao Yu63189b72018-03-08 14:22:56 +08001367 seq_printf(seq, ",active_logs=%u", F2FS_OPTION(sbi).active_logs);
Jaegeuk Kim7e65be42017-12-27 15:05:52 -08001368 if (test_opt(sbi, RESERVE_ROOT))
Jaegeuk Kim7c2e5962018-01-04 21:36:09 -08001369 seq_printf(seq, ",reserve_root=%u,resuid=%u,resgid=%u",
Chao Yu63189b72018-03-08 14:22:56 +08001370 F2FS_OPTION(sbi).root_reserved_blocks,
1371 from_kuid_munged(&init_user_ns,
1372 F2FS_OPTION(sbi).s_resuid),
1373 from_kgid_munged(&init_user_ns,
1374 F2FS_OPTION(sbi).s_resgid));
Jaegeuk Kimec915382016-12-21 17:09:19 -08001375 if (F2FS_IO_SIZE_BITS(sbi))
Chengguang Xuc6b18672018-09-22 22:43:09 +08001376 seq_printf(seq, ",io_bits=%u",
1377 F2FS_OPTION(sbi).write_io_size_bits);
Kaixu Xia0cc0dec2017-01-27 09:35:37 +08001378#ifdef CONFIG_F2FS_FAULT_INJECTION
Chao Yud4945002018-08-08 17:36:41 +08001379 if (test_opt(sbi, FAULT_INJECTION)) {
Chao Yu44529f82017-06-12 09:44:24 +08001380 seq_printf(seq, ",fault_injection=%u",
Chao Yu63189b72018-03-08 14:22:56 +08001381 F2FS_OPTION(sbi).fault_info.inject_rate);
Chao Yud4945002018-08-08 17:36:41 +08001382 seq_printf(seq, ",fault_type=%u",
1383 F2FS_OPTION(sbi).fault_info.inject_type);
1384 }
Kaixu Xia0cc0dec2017-01-27 09:35:37 +08001385#endif
Chao Yu0abd6752017-07-09 00:13:07 +08001386#ifdef CONFIG_QUOTA
Chao Yu4b2414d2017-08-08 10:54:31 +08001387 if (test_opt(sbi, QUOTA))
1388 seq_puts(seq, ",quota");
Chao Yu0abd6752017-07-09 00:13:07 +08001389 if (test_opt(sbi, USRQUOTA))
1390 seq_puts(seq, ",usrquota");
1391 if (test_opt(sbi, GRPQUOTA))
1392 seq_puts(seq, ",grpquota");
Chao Yu5c571322017-07-26 00:01:41 +08001393 if (test_opt(sbi, PRJQUOTA))
1394 seq_puts(seq, ",prjquota");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001395#endif
Chao Yu4b2414d2017-08-08 10:54:31 +08001396 f2fs_show_quota_options(seq, sbi->sb);
Chao Yu63189b72018-03-08 14:22:56 +08001397 if (F2FS_OPTION(sbi).whint_mode == WHINT_MODE_USER)
Hyunchul Lee0cdd3192018-01-31 11:36:57 +09001398 seq_printf(seq, ",whint_mode=%s", "user-based");
Chao Yu63189b72018-03-08 14:22:56 +08001399 else if (F2FS_OPTION(sbi).whint_mode == WHINT_MODE_FS)
Hyunchul Leef2e703f2018-01-31 11:36:58 +09001400 seq_printf(seq, ",whint_mode=%s", "fs-based");
Sheng Yongff62af22018-03-15 18:51:42 +08001401#ifdef CONFIG_F2FS_FS_ENCRYPTION
1402 if (F2FS_OPTION(sbi).test_dummy_encryption)
1403 seq_puts(seq, ",test_dummy_encryption");
1404#endif
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001405
Chao Yu63189b72018-03-08 14:22:56 +08001406 if (F2FS_OPTION(sbi).alloc_mode == ALLOC_MODE_DEFAULT)
Jaegeuk Kim07939622018-02-18 08:50:49 -08001407 seq_printf(seq, ",alloc_mode=%s", "default");
Chao Yu63189b72018-03-08 14:22:56 +08001408 else if (F2FS_OPTION(sbi).alloc_mode == ALLOC_MODE_REUSE)
Jaegeuk Kim07939622018-02-18 08:50:49 -08001409 seq_printf(seq, ",alloc_mode=%s", "reuse");
Junling Zheng93cf93f2018-03-07 12:07:49 +08001410
Daniel Rosenberg43549942018-08-20 19:21:43 -07001411 if (test_opt(sbi, DISABLE_CHECKPOINT))
1412 seq_puts(seq, ",checkpoint=disable");
1413
Chao Yu63189b72018-03-08 14:22:56 +08001414 if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_POSIX)
Junling Zheng93cf93f2018-03-07 12:07:49 +08001415 seq_printf(seq, ",fsync_mode=%s", "posix");
Chao Yu63189b72018-03-08 14:22:56 +08001416 else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT)
Junling Zheng93cf93f2018-03-07 12:07:49 +08001417 seq_printf(seq, ",fsync_mode=%s", "strict");
Sahitya Tummaladc132802018-07-02 11:37:40 +05301418 else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_NOBARRIER)
1419 seq_printf(seq, ",fsync_mode=%s", "nobarrier");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09001420 return 0;
1421}
1422
Yunlei He498c5e92015-05-07 18:11:37 +08001423static void default_options(struct f2fs_sb_info *sbi)
1424{
1425 /* init some FS parameters */
Chao Yu63189b72018-03-08 14:22:56 +08001426 F2FS_OPTION(sbi).active_logs = NR_CURSEG_TYPE;
1427 F2FS_OPTION(sbi).inline_xattr_size = DEFAULT_INLINE_XATTR_ADDRS;
1428 F2FS_OPTION(sbi).whint_mode = WHINT_MODE_OFF;
1429 F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;
1430 F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;
Sheng Yongff62af22018-03-15 18:51:42 +08001431 F2FS_OPTION(sbi).test_dummy_encryption = false;
Chao Yu0aa7e0f2018-06-06 23:55:02 +08001432 F2FS_OPTION(sbi).s_resuid = make_kuid(&init_user_ns, F2FS_DEF_RESUID);
1433 F2FS_OPTION(sbi).s_resgid = make_kgid(&init_user_ns, F2FS_DEF_RESGID);
Yunlei He498c5e92015-05-07 18:11:37 +08001434
1435 set_opt(sbi, BG_GC);
Chao Yu39133a52017-02-08 17:39:44 +08001436 set_opt(sbi, INLINE_XATTR);
Yunlei He498c5e92015-05-07 18:11:37 +08001437 set_opt(sbi, INLINE_DATA);
Chao Yu97c17942016-05-09 19:56:34 +08001438 set_opt(sbi, INLINE_DENTRY);
Jaegeuk Kim3e72f722015-06-19 17:53:26 -07001439 set_opt(sbi, EXTENT_CACHE);
Jaegeuk Kim7a20b8a2017-03-24 20:41:45 -04001440 set_opt(sbi, NOHEAP);
Daniel Rosenberg43549942018-08-20 19:21:43 -07001441 clear_opt(sbi, DISABLE_CHECKPOINT);
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001442 sbi->sb->s_flags |= SB_LAZYTIME;
Jaegeuk Kim69e9e422016-05-20 22:39:20 -07001443 set_opt(sbi, FLUSH_MERGE);
Chao Yu7d20c8a2018-09-04 03:52:17 +08001444 set_opt(sbi, DISCARD);
Chao Yu7beb01f2018-10-24 18:34:26 +08001445 if (f2fs_sb_has_blkzoned(sbi))
Chao Yua39e53652018-07-05 14:24:11 +08001446 set_opt_mode(sbi, F2FS_MOUNT_LFS);
1447 else
Jaegeuk Kim52763a42016-06-13 09:47:48 -07001448 set_opt_mode(sbi, F2FS_MOUNT_ADAPTIVE);
Yunlei He498c5e92015-05-07 18:11:37 +08001449
1450#ifdef CONFIG_F2FS_FS_XATTR
1451 set_opt(sbi, XATTR_USER);
1452#endif
1453#ifdef CONFIG_F2FS_FS_POSIX_ACL
1454 set_opt(sbi, POSIX_ACL);
1455#endif
Chao Yu36dbd322016-09-26 19:45:05 +08001456
Chao Yud4945002018-08-08 17:36:41 +08001457 f2fs_build_fault_attr(sbi, 0, 0);
Yunlei He498c5e92015-05-07 18:11:37 +08001458}
1459
Jaegeuk Kimea676732017-10-06 09:14:28 -07001460#ifdef CONFIG_QUOTA
1461static int f2fs_enable_quotas(struct super_block *sb);
1462#endif
Daniel Rosenberg43549942018-08-20 19:21:43 -07001463
1464static int f2fs_disable_checkpoint(struct f2fs_sb_info *sbi)
1465{
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001466 unsigned int s_flags = sbi->sb->s_flags;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001467 struct cp_control cpc;
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001468 int err = 0;
1469 int ret;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001470
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001471 if (s_flags & SB_RDONLY) {
1472 f2fs_msg(sbi->sb, KERN_ERR,
1473 "checkpoint=disable on readonly fs");
1474 return -EINVAL;
1475 }
Daniel Rosenberg43549942018-08-20 19:21:43 -07001476 sbi->sb->s_flags |= SB_ACTIVE;
1477
Daniel Rosenberg43549942018-08-20 19:21:43 -07001478 f2fs_update_time(sbi, DISABLE_TIME);
1479
1480 while (!f2fs_time_over(sbi, DISABLE_TIME)) {
Jaegeuk Kim8f31b462018-12-17 17:08:26 -08001481 mutex_lock(&sbi->gc_mutex);
Daniel Rosenberg43549942018-08-20 19:21:43 -07001482 err = f2fs_gc(sbi, true, false, NULL_SEGNO);
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001483 if (err == -ENODATA) {
1484 err = 0;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001485 break;
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001486 }
Jaegeuk Kim8f31b462018-12-17 17:08:26 -08001487 if (err && err != -EAGAIN)
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001488 break;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001489 }
Daniel Rosenberg43549942018-08-20 19:21:43 -07001490
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001491 ret = sync_filesystem(sbi->sb);
1492 if (ret || err) {
1493 err = ret ? ret: err;
1494 goto restore_flag;
1495 }
Daniel Rosenberg43549942018-08-20 19:21:43 -07001496
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001497 if (f2fs_disable_cp_again(sbi)) {
1498 err = -EAGAIN;
1499 goto restore_flag;
1500 }
Daniel Rosenberg43549942018-08-20 19:21:43 -07001501
1502 mutex_lock(&sbi->gc_mutex);
1503 cpc.reason = CP_PAUSE;
1504 set_sbi_flag(sbi, SBI_CP_DISABLED);
1505 f2fs_write_checkpoint(sbi, &cpc);
1506
1507 sbi->unusable_block_count = 0;
1508 mutex_unlock(&sbi->gc_mutex);
Jaegeuk Kim812a9592019-01-22 14:04:33 -08001509restore_flag:
1510 sbi->sb->s_flags = s_flags; /* Restore MS_RDONLY status */
1511 return err;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001512}
1513
1514static void f2fs_enable_checkpoint(struct f2fs_sb_info *sbi)
1515{
1516 mutex_lock(&sbi->gc_mutex);
1517 f2fs_dirty_to_prefree(sbi);
1518
1519 clear_sbi_flag(sbi, SBI_CP_DISABLED);
1520 set_sbi_flag(sbi, SBI_IS_DIRTY);
1521 mutex_unlock(&sbi->gc_mutex);
1522
1523 f2fs_sync_fs(sbi->sb, 1);
1524}
1525
Namjae Jeon696c0182013-06-16 09:48:48 +09001526static int f2fs_remount(struct super_block *sb, int *flags, char *data)
1527{
1528 struct f2fs_sb_info *sbi = F2FS_SB(sb);
1529 struct f2fs_mount_info org_mount_opt;
Chao Yu0abd6752017-07-09 00:13:07 +08001530 unsigned long old_sb_flags;
Chao Yu63189b72018-03-08 14:22:56 +08001531 int err;
Gu Zheng876dc592014-04-11 17:50:00 +08001532 bool need_restart_gc = false;
1533 bool need_stop_gc = false;
Chao Yu9cd81ce2015-09-18 16:55:26 +08001534 bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE);
Daniel Rosenberg43549942018-08-20 19:21:43 -07001535 bool disable_checkpoint = test_opt(sbi, DISABLE_CHECKPOINT);
1536 bool checkpoint_changed;
Chao Yu4b2414d2017-08-08 10:54:31 +08001537#ifdef CONFIG_QUOTA
Chao Yu4b2414d2017-08-08 10:54:31 +08001538 int i, j;
1539#endif
Namjae Jeon696c0182013-06-16 09:48:48 +09001540
1541 /*
1542 * Save the old mount options in case we
1543 * need to restore them.
1544 */
1545 org_mount_opt = sbi->mount_opt;
Chao Yu0abd6752017-07-09 00:13:07 +08001546 old_sb_flags = sb->s_flags;
Namjae Jeon696c0182013-06-16 09:48:48 +09001547
Chao Yu4b2414d2017-08-08 10:54:31 +08001548#ifdef CONFIG_QUOTA
Chao Yu63189b72018-03-08 14:22:56 +08001549 org_mount_opt.s_jquota_fmt = F2FS_OPTION(sbi).s_jquota_fmt;
Chao Yu4b2414d2017-08-08 10:54:31 +08001550 for (i = 0; i < MAXQUOTAS; i++) {
Chao Yu63189b72018-03-08 14:22:56 +08001551 if (F2FS_OPTION(sbi).s_qf_names[i]) {
1552 org_mount_opt.s_qf_names[i] =
1553 kstrdup(F2FS_OPTION(sbi).s_qf_names[i],
1554 GFP_KERNEL);
1555 if (!org_mount_opt.s_qf_names[i]) {
Chao Yu4b2414d2017-08-08 10:54:31 +08001556 for (j = 0; j < i; j++)
Jaegeuk Kim52225952018-12-13 18:38:33 -08001557 kvfree(org_mount_opt.s_qf_names[j]);
Chao Yu4b2414d2017-08-08 10:54:31 +08001558 return -ENOMEM;
1559 }
1560 } else {
Chao Yu63189b72018-03-08 14:22:56 +08001561 org_mount_opt.s_qf_names[i] = NULL;
Chao Yu4b2414d2017-08-08 10:54:31 +08001562 }
1563 }
1564#endif
1565
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07001566 /* recover superblocks we couldn't write due to previous RO mount */
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001567 if (!(*flags & SB_RDONLY) && is_sbi_flag_set(sbi, SBI_NEED_SB_WRITE)) {
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07001568 err = f2fs_commit_super(sbi, false);
1569 f2fs_msg(sb, KERN_INFO,
1570 "Try to recover all the superblocks, ret: %d", err);
1571 if (!err)
1572 clear_sbi_flag(sbi, SBI_NEED_SB_WRITE);
1573 }
1574
Yunlei He498c5e92015-05-07 18:11:37 +08001575 default_options(sbi);
Chao Yu26666c82014-09-15 18:04:44 +08001576
Namjae Jeon696c0182013-06-16 09:48:48 +09001577 /* parse mount options */
1578 err = parse_options(sb, data);
1579 if (err)
1580 goto restore_opts;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001581 checkpoint_changed =
1582 disable_checkpoint != test_opt(sbi, DISABLE_CHECKPOINT);
Namjae Jeon696c0182013-06-16 09:48:48 +09001583
1584 /*
1585 * Previous and new state of filesystem is RO,
Gu Zheng876dc592014-04-11 17:50:00 +08001586 * so skip checking GC and FLUSH_MERGE conditions.
Namjae Jeon696c0182013-06-16 09:48:48 +09001587 */
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001588 if (f2fs_readonly(sb) && (*flags & SB_RDONLY))
Namjae Jeon696c0182013-06-16 09:48:48 +09001589 goto skip;
1590
Jaegeuk Kimea676732017-10-06 09:14:28 -07001591#ifdef CONFIG_QUOTA
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001592 if (!f2fs_readonly(sb) && (*flags & SB_RDONLY)) {
Chao Yu0abd6752017-07-09 00:13:07 +08001593 err = dquot_suspend(sb, -1);
1594 if (err < 0)
1595 goto restore_opts;
Daniel Rosenberg43549942018-08-20 19:21:43 -07001596 } else if (f2fs_readonly(sb) && !(*flags & SB_RDONLY)) {
Chao Yu0abd6752017-07-09 00:13:07 +08001597 /* dquot_resume needs RW */
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001598 sb->s_flags &= ~SB_RDONLY;
Jaegeuk Kimea676732017-10-06 09:14:28 -07001599 if (sb_any_quota_suspended(sb)) {
1600 dquot_resume(sb, -1);
Chao Yu7beb01f2018-10-24 18:34:26 +08001601 } else if (f2fs_sb_has_quota_ino(sbi)) {
Jaegeuk Kimea676732017-10-06 09:14:28 -07001602 err = f2fs_enable_quotas(sb);
1603 if (err)
1604 goto restore_opts;
1605 }
Chao Yu0abd6752017-07-09 00:13:07 +08001606 }
Jaegeuk Kimea676732017-10-06 09:14:28 -07001607#endif
Chao Yu9cd81ce2015-09-18 16:55:26 +08001608 /* disallow enable/disable extent_cache dynamically */
1609 if (no_extent_cache == !!test_opt(sbi, EXTENT_CACHE)) {
1610 err = -EINVAL;
1611 f2fs_msg(sbi->sb, KERN_WARNING,
1612 "switch extent_cache option is not allowed");
1613 goto restore_opts;
1614 }
1615
Daniel Rosenberg43549942018-08-20 19:21:43 -07001616 if ((*flags & SB_RDONLY) && test_opt(sbi, DISABLE_CHECKPOINT)) {
1617 err = -EINVAL;
1618 f2fs_msg(sbi->sb, KERN_WARNING,
1619 "disabling checkpoint not compatible with read-only");
1620 goto restore_opts;
1621 }
1622
Namjae Jeon696c0182013-06-16 09:48:48 +09001623 /*
1624 * We stop the GC thread if FS is mounted as RO
1625 * or if background_gc = off is passed in mount
1626 * option. Also sync the filesystem.
1627 */
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001628 if ((*flags & SB_RDONLY) || !test_opt(sbi, BG_GC)) {
Namjae Jeon696c0182013-06-16 09:48:48 +09001629 if (sbi->gc_thread) {
Chao Yu4d57b862018-05-30 00:20:41 +08001630 f2fs_stop_gc_thread(sbi);
Gu Zheng876dc592014-04-11 17:50:00 +08001631 need_restart_gc = true;
Namjae Jeon696c0182013-06-16 09:48:48 +09001632 }
Chao Yuaba291b2014-11-18 11:17:20 +08001633 } else if (!sbi->gc_thread) {
Chao Yu4d57b862018-05-30 00:20:41 +08001634 err = f2fs_start_gc_thread(sbi);
Namjae Jeon696c0182013-06-16 09:48:48 +09001635 if (err)
1636 goto restore_opts;
Gu Zheng876dc592014-04-11 17:50:00 +08001637 need_stop_gc = true;
1638 }
1639
Chao Yu63189b72018-03-08 14:22:56 +08001640 if (*flags & SB_RDONLY ||
1641 F2FS_OPTION(sbi).whint_mode != org_mount_opt.whint_mode) {
Jaegeuk Kimfaa0e552016-03-24 10:29:39 -07001642 writeback_inodes_sb(sb, WB_REASON_SYNC);
1643 sync_inodes_sb(sb);
1644
1645 set_sbi_flag(sbi, SBI_IS_DIRTY);
1646 set_sbi_flag(sbi, SBI_IS_CLOSE);
1647 f2fs_sync_fs(sb, 1);
1648 clear_sbi_flag(sbi, SBI_IS_CLOSE);
1649 }
1650
Daniel Rosenberg43549942018-08-20 19:21:43 -07001651 if (checkpoint_changed) {
1652 if (test_opt(sbi, DISABLE_CHECKPOINT)) {
1653 err = f2fs_disable_checkpoint(sbi);
1654 if (err)
1655 goto restore_gc;
1656 } else {
1657 f2fs_enable_checkpoint(sbi);
1658 }
1659 }
1660
Gu Zheng876dc592014-04-11 17:50:00 +08001661 /*
1662 * We stop issue flush thread if FS is mounted as RO
1663 * or if flush_merge is not passed in mount option.
1664 */
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001665 if ((*flags & SB_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {
Jaegeuk Kim5eba8c52016-12-07 16:23:32 -08001666 clear_opt(sbi, FLUSH_MERGE);
Chao Yu4d57b862018-05-30 00:20:41 +08001667 f2fs_destroy_flush_cmd_control(sbi, false);
Jaegeuk Kim5eba8c52016-12-07 16:23:32 -08001668 } else {
Chao Yu4d57b862018-05-30 00:20:41 +08001669 err = f2fs_create_flush_cmd_control(sbi);
Gu Zheng2163d192014-04-27 14:21:33 +08001670 if (err)
Gu Zhenga688b9d9e2014-04-27 14:21:21 +08001671 goto restore_gc;
Namjae Jeon696c0182013-06-16 09:48:48 +09001672 }
1673skip:
Chao Yu4b2414d2017-08-08 10:54:31 +08001674#ifdef CONFIG_QUOTA
1675 /* Release old quota file names */
1676 for (i = 0; i < MAXQUOTAS; i++)
Jaegeuk Kim52225952018-12-13 18:38:33 -08001677 kvfree(org_mount_opt.s_qf_names[i]);
Chao Yu4b2414d2017-08-08 10:54:31 +08001678#endif
Namjae Jeon696c0182013-06-16 09:48:48 +09001679 /* Update the POSIXACL Flag */
Linus Torvalds1751e8a2017-11-27 13:05:09 -08001680 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
1681 (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07001682
Jaegeuk Kim7e65be42017-12-27 15:05:52 -08001683 limit_reserve_root(sbi);
Jaegeuk Kim095680f2018-09-28 00:24:39 -07001684 *flags = (*flags & ~SB_LAZYTIME) | (sb->s_flags & SB_LAZYTIME);
Namjae Jeon696c0182013-06-16 09:48:48 +09001685 return 0;
Gu Zheng876dc592014-04-11 17:50:00 +08001686restore_gc:
1687 if (need_restart_gc) {
Chao Yu4d57b862018-05-30 00:20:41 +08001688 if (f2fs_start_gc_thread(sbi))
Gu Zheng876dc592014-04-11 17:50:00 +08001689 f2fs_msg(sbi->sb, KERN_WARNING,
arter97e1c42042014-08-06 23:22:50 +09001690 "background gc thread has stopped");
Gu Zheng876dc592014-04-11 17:50:00 +08001691 } else if (need_stop_gc) {
Chao Yu4d57b862018-05-30 00:20:41 +08001692 f2fs_stop_gc_thread(sbi);
Gu Zheng876dc592014-04-11 17:50:00 +08001693 }
Namjae Jeon696c0182013-06-16 09:48:48 +09001694restore_opts:
Chao Yu4b2414d2017-08-08 10:54:31 +08001695#ifdef CONFIG_QUOTA
Chao Yu63189b72018-03-08 14:22:56 +08001696 F2FS_OPTION(sbi).s_jquota_fmt = org_mount_opt.s_jquota_fmt;
Chao Yu4b2414d2017-08-08 10:54:31 +08001697 for (i = 0; i < MAXQUOTAS; i++) {
Jaegeuk Kim52225952018-12-13 18:38:33 -08001698 kvfree(F2FS_OPTION(sbi).s_qf_names[i]);
Chao Yu63189b72018-03-08 14:22:56 +08001699 F2FS_OPTION(sbi).s_qf_names[i] = org_mount_opt.s_qf_names[i];
Chao Yu4b2414d2017-08-08 10:54:31 +08001700 }
1701#endif
Namjae Jeon696c0182013-06-16 09:48:48 +09001702 sbi->mount_opt = org_mount_opt;
Chao Yu0abd6752017-07-09 00:13:07 +08001703 sb->s_flags = old_sb_flags;
Namjae Jeon696c0182013-06-16 09:48:48 +09001704 return err;
1705}
1706
Chao Yu0abd6752017-07-09 00:13:07 +08001707#ifdef CONFIG_QUOTA
1708/* Read data from quotafile */
1709static ssize_t f2fs_quota_read(struct super_block *sb, int type, char *data,
1710 size_t len, loff_t off)
1711{
1712 struct inode *inode = sb_dqopt(sb)->files[type];
1713 struct address_space *mapping = inode->i_mapping;
1714 block_t blkidx = F2FS_BYTES_TO_BLK(off);
1715 int offset = off & (sb->s_blocksize - 1);
1716 int tocopy;
1717 size_t toread;
1718 loff_t i_size = i_size_read(inode);
1719 struct page *page;
1720 char *kaddr;
1721
1722 if (off > i_size)
1723 return 0;
1724
1725 if (off + len > i_size)
1726 len = i_size - off;
1727 toread = len;
1728 while (toread > 0) {
1729 tocopy = min_t(unsigned long, sb->s_blocksize - offset, toread);
1730repeat:
Ritesh Harjani02117b82018-03-16 18:53:53 +05301731 page = read_cache_page_gfp(mapping, blkidx, GFP_NOFS);
Jaegeuk Kim4e46a022017-10-19 09:43:56 -07001732 if (IS_ERR(page)) {
1733 if (PTR_ERR(page) == -ENOMEM) {
1734 congestion_wait(BLK_RW_ASYNC, HZ/50);
1735 goto repeat;
1736 }
Chao Yuaf033b22018-09-20 20:05:00 +08001737 set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
Chao Yu0abd6752017-07-09 00:13:07 +08001738 return PTR_ERR(page);
Jaegeuk Kim4e46a022017-10-19 09:43:56 -07001739 }
Chao Yu0abd6752017-07-09 00:13:07 +08001740
1741 lock_page(page);
1742
1743 if (unlikely(page->mapping != mapping)) {
1744 f2fs_put_page(page, 1);
1745 goto repeat;
1746 }
1747 if (unlikely(!PageUptodate(page))) {
1748 f2fs_put_page(page, 1);
Chao Yuaf033b22018-09-20 20:05:00 +08001749 set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
Chao Yu0abd6752017-07-09 00:13:07 +08001750 return -EIO;
1751 }
1752
1753 kaddr = kmap_atomic(page);
1754 memcpy(data, kaddr + offset, tocopy);
1755 kunmap_atomic(kaddr);
1756 f2fs_put_page(page, 1);
1757
1758 offset = 0;
1759 toread -= tocopy;
1760 data += tocopy;
1761 blkidx++;
1762 }
1763 return len;
1764}
1765
1766/* Write to quotafile */
1767static ssize_t f2fs_quota_write(struct super_block *sb, int type,
1768 const char *data, size_t len, loff_t off)
1769{
1770 struct inode *inode = sb_dqopt(sb)->files[type];
1771 struct address_space *mapping = inode->i_mapping;
1772 const struct address_space_operations *a_ops = mapping->a_ops;
1773 int offset = off & (sb->s_blocksize - 1);
1774 size_t towrite = len;
1775 struct page *page;
1776 char *kaddr;
1777 int err = 0;
1778 int tocopy;
1779
1780 while (towrite > 0) {
1781 tocopy = min_t(unsigned long, sb->s_blocksize - offset,
1782 towrite);
Jaegeuk Kim4e46a022017-10-19 09:43:56 -07001783retry:
Chao Yu0abd6752017-07-09 00:13:07 +08001784 err = a_ops->write_begin(NULL, mapping, off, tocopy, 0,
1785 &page, NULL);
Jaegeuk Kim4e46a022017-10-19 09:43:56 -07001786 if (unlikely(err)) {
1787 if (err == -ENOMEM) {
1788 congestion_wait(BLK_RW_ASYNC, HZ/50);
1789 goto retry;
1790 }
Chao Yuaf033b22018-09-20 20:05:00 +08001791 set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
Chao Yu0abd6752017-07-09 00:13:07 +08001792 break;
Jaegeuk Kim4e46a022017-10-19 09:43:56 -07001793 }
Chao Yu0abd6752017-07-09 00:13:07 +08001794
1795 kaddr = kmap_atomic(page);
1796 memcpy(kaddr + offset, data, tocopy);
1797 kunmap_atomic(kaddr);
1798 flush_dcache_page(page);
1799
1800 a_ops->write_end(NULL, mapping, off, tocopy, tocopy,
1801 page, NULL);
1802 offset = 0;
1803 towrite -= tocopy;
1804 off += tocopy;
1805 data += tocopy;
1806 cond_resched();
1807 }
1808
1809 if (len == towrite)
Jaegeuk Kim6e5b5d42017-10-19 12:07:11 -07001810 return err;
Chao Yu0abd6752017-07-09 00:13:07 +08001811 inode->i_mtime = inode->i_ctime = current_time(inode);
1812 f2fs_mark_inode_dirty_sync(inode, false);
1813 return len - towrite;
1814}
1815
1816static struct dquot **f2fs_get_dquots(struct inode *inode)
1817{
1818 return F2FS_I(inode)->i_dquot;
1819}
1820
1821static qsize_t *f2fs_get_reserved_space(struct inode *inode)
1822{
1823 return &F2FS_I(inode)->i_reserved_quota;
1824}
1825
Chao Yu4b2414d2017-08-08 10:54:31 +08001826static int f2fs_quota_on_mount(struct f2fs_sb_info *sbi, int type)
1827{
Chao Yuaf033b22018-09-20 20:05:00 +08001828 if (is_set_ckpt_flags(sbi, CP_QUOTA_NEED_FSCK_FLAG)) {
1829 f2fs_msg(sbi->sb, KERN_ERR,
1830 "quota sysfile may be corrupted, skip loading it");
1831 return 0;
1832 }
1833
Chao Yu63189b72018-03-08 14:22:56 +08001834 return dquot_quota_on_mount(sbi->sb, F2FS_OPTION(sbi).s_qf_names[type],
1835 F2FS_OPTION(sbi).s_jquota_fmt, type);
Chao Yu4b2414d2017-08-08 10:54:31 +08001836}
1837
Jaegeuk Kimea676732017-10-06 09:14:28 -07001838int f2fs_enable_quota_files(struct f2fs_sb_info *sbi, bool rdonly)
Chao Yu4b2414d2017-08-08 10:54:31 +08001839{
Jaegeuk Kimea676732017-10-06 09:14:28 -07001840 int enabled = 0;
1841 int i, err;
1842
Chao Yu7beb01f2018-10-24 18:34:26 +08001843 if (f2fs_sb_has_quota_ino(sbi) && rdonly) {
Jaegeuk Kimea676732017-10-06 09:14:28 -07001844 err = f2fs_enable_quotas(sbi->sb);
1845 if (err) {
1846 f2fs_msg(sbi->sb, KERN_ERR,
1847 "Cannot turn on quota_ino: %d", err);
1848 return 0;
1849 }
1850 return 1;
1851 }
Chao Yu4b2414d2017-08-08 10:54:31 +08001852
1853 for (i = 0; i < MAXQUOTAS; i++) {
Chao Yu63189b72018-03-08 14:22:56 +08001854 if (F2FS_OPTION(sbi).s_qf_names[i]) {
Jaegeuk Kimea676732017-10-06 09:14:28 -07001855 err = f2fs_quota_on_mount(sbi, i);
1856 if (!err) {
1857 enabled = 1;
1858 continue;
1859 }
1860 f2fs_msg(sbi->sb, KERN_ERR,
1861 "Cannot turn on quotas: %d on %d", err, i);
Chao Yu4b2414d2017-08-08 10:54:31 +08001862 }
1863 }
Jaegeuk Kimea676732017-10-06 09:14:28 -07001864 return enabled;
1865}
1866
1867static int f2fs_quota_enable(struct super_block *sb, int type, int format_id,
1868 unsigned int flags)
1869{
1870 struct inode *qf_inode;
1871 unsigned long qf_inum;
1872 int err;
1873
Chao Yu7beb01f2018-10-24 18:34:26 +08001874 BUG_ON(!f2fs_sb_has_quota_ino(F2FS_SB(sb)));
Jaegeuk Kimea676732017-10-06 09:14:28 -07001875
1876 qf_inum = f2fs_qf_ino(sb, type);
1877 if (!qf_inum)
1878 return -EPERM;
1879
1880 qf_inode = f2fs_iget(sb, qf_inum);
1881 if (IS_ERR(qf_inode)) {
1882 f2fs_msg(sb, KERN_ERR,
1883 "Bad quota inode %u:%lu", type, qf_inum);
1884 return PTR_ERR(qf_inode);
1885 }
1886
1887 /* Don't account quota for quota files to avoid recursion */
1888 qf_inode->i_flags |= S_NOQUOTA;
1889 err = dquot_enable(qf_inode, type, format_id, flags);
1890 iput(qf_inode);
1891 return err;
1892}
1893
1894static int f2fs_enable_quotas(struct super_block *sb)
1895{
1896 int type, err = 0;
1897 unsigned long qf_inum;
1898 bool quota_mopt[MAXQUOTAS] = {
1899 test_opt(F2FS_SB(sb), USRQUOTA),
1900 test_opt(F2FS_SB(sb), GRPQUOTA),
1901 test_opt(F2FS_SB(sb), PRJQUOTA),
1902 };
1903
Chao Yuaf033b22018-09-20 20:05:00 +08001904 if (is_set_ckpt_flags(F2FS_SB(sb), CP_QUOTA_NEED_FSCK_FLAG)) {
1905 f2fs_msg(sb, KERN_ERR,
1906 "quota file may be corrupted, skip loading it");
1907 return 0;
1908 }
1909
1910 sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE;
1911
Jaegeuk Kimea676732017-10-06 09:14:28 -07001912 for (type = 0; type < MAXQUOTAS; type++) {
1913 qf_inum = f2fs_qf_ino(sb, type);
1914 if (qf_inum) {
1915 err = f2fs_quota_enable(sb, type, QFMT_VFS_V1,
1916 DQUOT_USAGE_ENABLED |
1917 (quota_mopt[type] ? DQUOT_LIMITS_ENABLED : 0));
1918 if (err) {
1919 f2fs_msg(sb, KERN_ERR,
1920 "Failed to enable quota tracking "
1921 "(type=%d, err=%d). Please run "
1922 "fsck to fix.", type, err);
1923 for (type--; type >= 0; type--)
1924 dquot_quota_off(sb, type);
Chao Yuaf033b22018-09-20 20:05:00 +08001925 set_sbi_flag(F2FS_SB(sb),
1926 SBI_QUOTA_NEED_REPAIR);
Jaegeuk Kimea676732017-10-06 09:14:28 -07001927 return err;
1928 }
1929 }
1930 }
1931 return 0;
Chao Yu4b2414d2017-08-08 10:54:31 +08001932}
1933
Chao Yuaf033b22018-09-20 20:05:00 +08001934int f2fs_quota_sync(struct super_block *sb, int type)
Chao Yu0abd6752017-07-09 00:13:07 +08001935{
Chao Yuaf033b22018-09-20 20:05:00 +08001936 struct f2fs_sb_info *sbi = F2FS_SB(sb);
Chao Yu0abd6752017-07-09 00:13:07 +08001937 struct quota_info *dqopt = sb_dqopt(sb);
1938 int cnt;
1939 int ret;
1940
1941 ret = dquot_writeback_dquots(sb, type);
1942 if (ret)
Chao Yuaf033b22018-09-20 20:05:00 +08001943 goto out;
Chao Yu0abd6752017-07-09 00:13:07 +08001944
1945 /*
1946 * Now when everything is written we can discard the pagecache so
1947 * that userspace sees the changes.
1948 */
1949 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Chao Yuaf033b22018-09-20 20:05:00 +08001950 struct address_space *mapping;
1951
Chao Yu0abd6752017-07-09 00:13:07 +08001952 if (type != -1 && cnt != type)
1953 continue;
1954 if (!sb_has_quota_active(sb, cnt))
1955 continue;
1956
Chao Yuaf033b22018-09-20 20:05:00 +08001957 mapping = dqopt->files[cnt]->i_mapping;
1958
1959 ret = filemap_fdatawrite(mapping);
Chao Yu0abd6752017-07-09 00:13:07 +08001960 if (ret)
Chao Yuaf033b22018-09-20 20:05:00 +08001961 goto out;
1962
1963 /* if we are using journalled quota */
1964 if (is_journalled_quota(sbi))
1965 continue;
1966
1967 ret = filemap_fdatawait(mapping);
1968 if (ret)
1969 set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
Chao Yu0abd6752017-07-09 00:13:07 +08001970
1971 inode_lock(dqopt->files[cnt]);
1972 truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
1973 inode_unlock(dqopt->files[cnt]);
1974 }
Chao Yuaf033b22018-09-20 20:05:00 +08001975out:
1976 if (ret)
1977 set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
1978 return ret;
Chao Yu0abd6752017-07-09 00:13:07 +08001979}
1980
1981static int f2fs_quota_on(struct super_block *sb, int type, int format_id,
1982 const struct path *path)
1983{
1984 struct inode *inode;
1985 int err;
1986
Chao Yu9a20d392017-08-07 16:37:59 +08001987 err = f2fs_quota_sync(sb, type);
Chao Yu0abd6752017-07-09 00:13:07 +08001988 if (err)
1989 return err;
1990
1991 err = dquot_quota_on(sb, type, format_id, path);
1992 if (err)
1993 return err;
1994
1995 inode = d_inode(path->dentry);
1996
1997 inode_lock(inode);
Chao Yu59c84402018-04-03 15:08:17 +08001998 F2FS_I(inode)->i_flags |= F2FS_NOATIME_FL | F2FS_IMMUTABLE_FL;
Chao Yu9149a5e2018-10-07 19:06:15 +08001999 f2fs_set_inode_flags(inode);
Chao Yu0abd6752017-07-09 00:13:07 +08002000 inode_unlock(inode);
2001 f2fs_mark_inode_dirty_sync(inode, false);
2002
2003 return 0;
2004}
2005
2006static int f2fs_quota_off(struct super_block *sb, int type)
2007{
2008 struct inode *inode = sb_dqopt(sb)->files[type];
2009 int err;
2010
2011 if (!inode || !igrab(inode))
2012 return dquot_quota_off(sb, type);
2013
Yunlei Hecda9cc52018-06-26 13:12:43 +08002014 err = f2fs_quota_sync(sb, type);
2015 if (err)
2016 goto out_put;
Chao Yu0abd6752017-07-09 00:13:07 +08002017
2018 err = dquot_quota_off(sb, type);
Chao Yu7beb01f2018-10-24 18:34:26 +08002019 if (err || f2fs_sb_has_quota_ino(F2FS_SB(sb)))
Chao Yu0abd6752017-07-09 00:13:07 +08002020 goto out_put;
2021
2022 inode_lock(inode);
Chao Yu59c84402018-04-03 15:08:17 +08002023 F2FS_I(inode)->i_flags &= ~(F2FS_NOATIME_FL | F2FS_IMMUTABLE_FL);
Chao Yu9149a5e2018-10-07 19:06:15 +08002024 f2fs_set_inode_flags(inode);
Chao Yu0abd6752017-07-09 00:13:07 +08002025 inode_unlock(inode);
2026 f2fs_mark_inode_dirty_sync(inode, false);
2027out_put:
2028 iput(inode);
2029 return err;
2030}
2031
Chao Yu4b2414d2017-08-08 10:54:31 +08002032void f2fs_quota_off_umount(struct super_block *sb)
Chao Yu0abd6752017-07-09 00:13:07 +08002033{
2034 int type;
Yunlei Hecda9cc52018-06-26 13:12:43 +08002035 int err;
Chao Yu0abd6752017-07-09 00:13:07 +08002036
Yunlei Hecda9cc52018-06-26 13:12:43 +08002037 for (type = 0; type < MAXQUOTAS; type++) {
2038 err = f2fs_quota_off(sb, type);
2039 if (err) {
2040 int ret = dquot_quota_off(sb, type);
2041
2042 f2fs_msg(sb, KERN_ERR,
2043 "Fail to turn off disk quota "
2044 "(type: %d, err: %d, ret:%d), Please "
2045 "run fsck to fix it.", type, err, ret);
Chao Yuaf033b22018-09-20 20:05:00 +08002046 set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
Yunlei Hecda9cc52018-06-26 13:12:43 +08002047 }
2048 }
Jaegeuk Kim0e0667b2019-01-27 17:59:53 -08002049 /*
2050 * In case of checkpoint=disable, we must flush quota blocks.
2051 * This can cause NULL exception for node_inode in end_io, since
2052 * put_super already dropped it.
2053 */
2054 sync_filesystem(sb);
Chao Yu0abd6752017-07-09 00:13:07 +08002055}
2056
Sheng Yong26b5a072018-10-12 18:49:26 +08002057static void f2fs_truncate_quota_inode_pages(struct super_block *sb)
2058{
2059 struct quota_info *dqopt = sb_dqopt(sb);
2060 int type;
2061
2062 for (type = 0; type < MAXQUOTAS; type++) {
2063 if (!dqopt->files[type])
2064 continue;
2065 f2fs_inode_synced(dqopt->files[type]);
2066 }
2067}
2068
Chao Yuaf033b22018-09-20 20:05:00 +08002069static int f2fs_dquot_commit(struct dquot *dquot)
2070{
2071 int ret;
2072
2073 ret = dquot_commit(dquot);
2074 if (ret < 0)
2075 set_sbi_flag(F2FS_SB(dquot->dq_sb), SBI_QUOTA_NEED_REPAIR);
2076 return ret;
2077}
2078
2079static int f2fs_dquot_acquire(struct dquot *dquot)
2080{
2081 int ret;
2082
2083 ret = dquot_acquire(dquot);
2084 if (ret < 0)
2085 set_sbi_flag(F2FS_SB(dquot->dq_sb), SBI_QUOTA_NEED_REPAIR);
2086
2087 return ret;
2088}
2089
2090static int f2fs_dquot_release(struct dquot *dquot)
2091{
2092 int ret;
2093
2094 ret = dquot_release(dquot);
2095 if (ret < 0)
2096 set_sbi_flag(F2FS_SB(dquot->dq_sb), SBI_QUOTA_NEED_REPAIR);
2097 return ret;
2098}
2099
2100static int f2fs_dquot_mark_dquot_dirty(struct dquot *dquot)
2101{
2102 struct super_block *sb = dquot->dq_sb;
2103 struct f2fs_sb_info *sbi = F2FS_SB(sb);
2104 int ret;
2105
2106 ret = dquot_mark_dquot_dirty(dquot);
2107
2108 /* if we are using journalled quota */
2109 if (is_journalled_quota(sbi))
2110 set_sbi_flag(sbi, SBI_QUOTA_NEED_FLUSH);
2111
2112 return ret;
2113}
2114
2115static int f2fs_dquot_commit_info(struct super_block *sb, int type)
2116{
2117 int ret;
2118
2119 ret = dquot_commit_info(sb, type);
2120 if (ret < 0)
2121 set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
2122 return ret;
2123}
Sheng Yong26b5a072018-10-12 18:49:26 +08002124
Wei Yongjun94b1e102018-01-05 09:41:20 +00002125static int f2fs_get_projid(struct inode *inode, kprojid_t *projid)
Chao Yu5c571322017-07-26 00:01:41 +08002126{
2127 *projid = F2FS_I(inode)->i_projid;
2128 return 0;
2129}
2130
Chao Yu0abd6752017-07-09 00:13:07 +08002131static const struct dquot_operations f2fs_quota_operations = {
2132 .get_reserved_space = f2fs_get_reserved_space,
Chao Yuaf033b22018-09-20 20:05:00 +08002133 .write_dquot = f2fs_dquot_commit,
2134 .acquire_dquot = f2fs_dquot_acquire,
2135 .release_dquot = f2fs_dquot_release,
2136 .mark_dirty = f2fs_dquot_mark_dquot_dirty,
2137 .write_info = f2fs_dquot_commit_info,
Chao Yu0abd6752017-07-09 00:13:07 +08002138 .alloc_dquot = dquot_alloc,
2139 .destroy_dquot = dquot_destroy,
Chao Yu5c571322017-07-26 00:01:41 +08002140 .get_projid = f2fs_get_projid,
Chao Yu0abd6752017-07-09 00:13:07 +08002141 .get_next_id = dquot_get_next_id,
2142};
2143
2144static const struct quotactl_ops f2fs_quotactl_ops = {
2145 .quota_on = f2fs_quota_on,
2146 .quota_off = f2fs_quota_off,
2147 .quota_sync = f2fs_quota_sync,
2148 .get_state = dquot_get_state,
2149 .set_info = dquot_set_dqinfo,
2150 .get_dqblk = dquot_get_dqblk,
2151 .set_dqblk = dquot_set_dqblk,
2152 .get_nextdqblk = dquot_get_next_dqblk,
2153};
2154#else
Chao Yuaf033b22018-09-20 20:05:00 +08002155int f2fs_quota_sync(struct super_block *sb, int type)
2156{
2157 return 0;
2158}
2159
Chao Yu4b2414d2017-08-08 10:54:31 +08002160void f2fs_quota_off_umount(struct super_block *sb)
Chao Yu0abd6752017-07-09 00:13:07 +08002161{
2162}
2163#endif
2164
Arvind Yadavf62fc9f2017-08-31 15:06:24 +05302165static const struct super_operations f2fs_sops = {
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002166 .alloc_inode = f2fs_alloc_inode,
Jaegeuk Kim531ad7d2013-04-30 11:33:27 +09002167 .drop_inode = f2fs_drop_inode,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002168 .destroy_inode = f2fs_destroy_inode,
2169 .write_inode = f2fs_write_inode,
Jaegeuk Kimb3783872013-06-10 09:17:01 +09002170 .dirty_inode = f2fs_dirty_inode,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002171 .show_options = f2fs_show_options,
Chao Yu0abd6752017-07-09 00:13:07 +08002172#ifdef CONFIG_QUOTA
2173 .quota_read = f2fs_quota_read,
2174 .quota_write = f2fs_quota_write,
2175 .get_dquots = f2fs_get_dquots,
2176#endif
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002177 .evict_inode = f2fs_evict_inode,
2178 .put_super = f2fs_put_super,
2179 .sync_fs = f2fs_sync_fs,
Changman Leed6212a52013-01-29 18:30:07 +09002180 .freeze_fs = f2fs_freeze,
2181 .unfreeze_fs = f2fs_unfreeze,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002182 .statfs = f2fs_statfs,
Namjae Jeon696c0182013-06-16 09:48:48 +09002183 .remount_fs = f2fs_remount,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002184};
2185
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07002186#ifdef CONFIG_F2FS_FS_ENCRYPTION
2187static int f2fs_get_context(struct inode *inode, void *ctx, size_t len)
2188{
2189 return f2fs_getxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,
2190 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,
2191 ctx, len, NULL);
2192}
2193
2194static int f2fs_set_context(struct inode *inode, const void *ctx, size_t len,
2195 void *fs_data)
2196{
Sheng Yongb7c409d2018-03-15 18:51:41 +08002197 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2198
2199 /*
2200 * Encrypting the root directory is not allowed because fsck
2201 * expects lost+found directory to exist and remain unencrypted
2202 * if LOST_FOUND feature is enabled.
2203 *
2204 */
Chao Yu7beb01f2018-10-24 18:34:26 +08002205 if (f2fs_sb_has_lost_found(sbi) &&
Sheng Yongb7c409d2018-03-15 18:51:41 +08002206 inode->i_ino == F2FS_ROOT_INO(sbi))
2207 return -EPERM;
2208
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07002209 return f2fs_setxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,
2210 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,
2211 ctx, len, fs_data, XATTR_CREATE);
2212}
2213
Sheng Yongff62af22018-03-15 18:51:42 +08002214static bool f2fs_dummy_context(struct inode *inode)
2215{
2216 return DUMMY_ENCRYPTION_ENABLED(F2FS_I_SB(inode));
2217}
2218
Eric Biggers6f69f0e2017-02-07 12:42:10 -08002219static const struct fscrypt_operations f2fs_cryptops = {
Eric Biggersa5d431e2017-01-05 13:51:18 -08002220 .key_prefix = "f2fs:",
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07002221 .get_context = f2fs_get_context,
2222 .set_context = f2fs_set_context,
Sheng Yongff62af22018-03-15 18:51:42 +08002223 .dummy_context = f2fs_dummy_context,
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07002224 .empty_dir = f2fs_empty_dir,
Eric Biggerse12ee682018-04-30 15:51:44 -07002225 .max_namelen = F2FS_NAME_LEN,
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07002226};
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07002227#endif
2228
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002229static struct inode *f2fs_nfs_get_inode(struct super_block *sb,
2230 u64 ino, u32 generation)
2231{
2232 struct f2fs_sb_info *sbi = F2FS_SB(sb);
2233 struct inode *inode;
2234
Chao Yu4d57b862018-05-30 00:20:41 +08002235 if (f2fs_check_nid_range(sbi, ino))
Chao Yu910bb122014-03-12 17:08:36 +08002236 return ERR_PTR(-ESTALE);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002237
2238 /*
2239 * f2fs_iget isn't quite right if the inode is currently unallocated!
2240 * However f2fs_iget currently does appropriate checks to handle stale
2241 * inodes so everything is OK.
2242 */
2243 inode = f2fs_iget(sb, ino);
2244 if (IS_ERR(inode))
2245 return ERR_CAST(inode);
Jaegeuk Kim6bacf522013-12-06 15:00:58 +09002246 if (unlikely(generation && inode->i_generation != generation)) {
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002247 /* we didn't find the right inode.. */
2248 iput(inode);
2249 return ERR_PTR(-ESTALE);
2250 }
2251 return inode;
2252}
2253
2254static struct dentry *f2fs_fh_to_dentry(struct super_block *sb, struct fid *fid,
2255 int fh_len, int fh_type)
2256{
2257 return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
2258 f2fs_nfs_get_inode);
2259}
2260
2261static struct dentry *f2fs_fh_to_parent(struct super_block *sb, struct fid *fid,
2262 int fh_len, int fh_type)
2263{
2264 return generic_fh_to_parent(sb, fid, fh_len, fh_type,
2265 f2fs_nfs_get_inode);
2266}
2267
2268static const struct export_operations f2fs_export_ops = {
2269 .fh_to_dentry = f2fs_fh_to_dentry,
2270 .fh_to_parent = f2fs_fh_to_parent,
2271 .get_parent = f2fs_get_parent,
2272};
2273
Chao Yue0afc4d2015-12-31 14:35:37 +08002274static loff_t max_file_blocks(void)
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002275{
Chao Yu7a2af762017-07-19 00:19:06 +08002276 loff_t result = 0;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002277 loff_t leaf_count = ADDRS_PER_BLOCK;
2278
Chao Yu7a2af762017-07-19 00:19:06 +08002279 /*
2280 * note: previously, result is equal to (DEF_ADDRS_PER_INODE -
Chao Yu6afc6622017-09-06 21:59:50 +08002281 * DEFAULT_INLINE_XATTR_ADDRS), but now f2fs try to reserve more
Chao Yu7a2af762017-07-19 00:19:06 +08002282 * space in inode.i_addr, it will be more safe to reassign
2283 * result as zero.
2284 */
2285
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002286 /* two direct node blocks */
2287 result += (leaf_count * 2);
2288
2289 /* two indirect node blocks */
2290 leaf_count *= NIDS_PER_BLOCK;
2291 result += (leaf_count * 2);
2292
2293 /* one double indirect node block */
2294 leaf_count *= NIDS_PER_BLOCK;
2295 result += leaf_count;
2296
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002297 return result;
2298}
2299
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002300static int __f2fs_commit_super(struct buffer_head *bh,
2301 struct f2fs_super_block *super)
Chao Yu9a59b622015-12-15 09:58:18 +08002302{
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002303 lock_buffer(bh);
2304 if (super)
2305 memcpy(bh->b_data + F2FS_SUPER_OFFSET, super, sizeof(*super));
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002306 set_buffer_dirty(bh);
2307 unlock_buffer(bh);
2308
2309 /* it's rare case, we can do fua all the time */
Jan Kara3adc5fcb2017-05-02 17:03:47 +02002310 return __sync_dirty_buffer(bh, REQ_SYNC | REQ_PREFLUSH | REQ_FUA);
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002311}
2312
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002313static inline bool sanity_check_area_boundary(struct f2fs_sb_info *sbi,
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002314 struct buffer_head *bh)
2315{
2316 struct f2fs_super_block *raw_super = (struct f2fs_super_block *)
2317 (bh->b_data + F2FS_SUPER_OFFSET);
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002318 struct super_block *sb = sbi->sb;
Chao Yu9a59b622015-12-15 09:58:18 +08002319 u32 segment0_blkaddr = le32_to_cpu(raw_super->segment0_blkaddr);
2320 u32 cp_blkaddr = le32_to_cpu(raw_super->cp_blkaddr);
2321 u32 sit_blkaddr = le32_to_cpu(raw_super->sit_blkaddr);
2322 u32 nat_blkaddr = le32_to_cpu(raw_super->nat_blkaddr);
2323 u32 ssa_blkaddr = le32_to_cpu(raw_super->ssa_blkaddr);
2324 u32 main_blkaddr = le32_to_cpu(raw_super->main_blkaddr);
2325 u32 segment_count_ckpt = le32_to_cpu(raw_super->segment_count_ckpt);
2326 u32 segment_count_sit = le32_to_cpu(raw_super->segment_count_sit);
2327 u32 segment_count_nat = le32_to_cpu(raw_super->segment_count_nat);
2328 u32 segment_count_ssa = le32_to_cpu(raw_super->segment_count_ssa);
2329 u32 segment_count_main = le32_to_cpu(raw_super->segment_count_main);
2330 u32 segment_count = le32_to_cpu(raw_super->segment_count);
2331 u32 log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002332 u64 main_end_blkaddr = main_blkaddr +
2333 (segment_count_main << log_blocks_per_seg);
2334 u64 seg_end_blkaddr = segment0_blkaddr +
2335 (segment_count << log_blocks_per_seg);
Chao Yu9a59b622015-12-15 09:58:18 +08002336
2337 if (segment0_blkaddr != cp_blkaddr) {
2338 f2fs_msg(sb, KERN_INFO,
2339 "Mismatch start address, segment0(%u) cp_blkaddr(%u)",
2340 segment0_blkaddr, cp_blkaddr);
2341 return true;
2342 }
2343
2344 if (cp_blkaddr + (segment_count_ckpt << log_blocks_per_seg) !=
2345 sit_blkaddr) {
2346 f2fs_msg(sb, KERN_INFO,
2347 "Wrong CP boundary, start(%u) end(%u) blocks(%u)",
2348 cp_blkaddr, sit_blkaddr,
2349 segment_count_ckpt << log_blocks_per_seg);
2350 return true;
2351 }
2352
2353 if (sit_blkaddr + (segment_count_sit << log_blocks_per_seg) !=
2354 nat_blkaddr) {
2355 f2fs_msg(sb, KERN_INFO,
2356 "Wrong SIT boundary, start(%u) end(%u) blocks(%u)",
2357 sit_blkaddr, nat_blkaddr,
2358 segment_count_sit << log_blocks_per_seg);
2359 return true;
2360 }
2361
2362 if (nat_blkaddr + (segment_count_nat << log_blocks_per_seg) !=
2363 ssa_blkaddr) {
2364 f2fs_msg(sb, KERN_INFO,
2365 "Wrong NAT boundary, start(%u) end(%u) blocks(%u)",
2366 nat_blkaddr, ssa_blkaddr,
2367 segment_count_nat << log_blocks_per_seg);
2368 return true;
2369 }
2370
2371 if (ssa_blkaddr + (segment_count_ssa << log_blocks_per_seg) !=
2372 main_blkaddr) {
2373 f2fs_msg(sb, KERN_INFO,
2374 "Wrong SSA boundary, start(%u) end(%u) blocks(%u)",
2375 ssa_blkaddr, main_blkaddr,
2376 segment_count_ssa << log_blocks_per_seg);
2377 return true;
2378 }
2379
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002380 if (main_end_blkaddr > seg_end_blkaddr) {
Chao Yu9a59b622015-12-15 09:58:18 +08002381 f2fs_msg(sb, KERN_INFO,
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002382 "Wrong MAIN_AREA boundary, start(%u) end(%u) block(%u)",
Chao Yu9a59b622015-12-15 09:58:18 +08002383 main_blkaddr,
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002384 segment0_blkaddr +
2385 (segment_count << log_blocks_per_seg),
Chao Yu9a59b622015-12-15 09:58:18 +08002386 segment_count_main << log_blocks_per_seg);
2387 return true;
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002388 } else if (main_end_blkaddr < seg_end_blkaddr) {
2389 int err = 0;
2390 char *res;
Chao Yu9a59b622015-12-15 09:58:18 +08002391
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002392 /* fix in-memory information all the time */
2393 raw_super->segment_count = cpu_to_le32((main_end_blkaddr -
2394 segment0_blkaddr) >> log_blocks_per_seg);
2395
2396 if (f2fs_readonly(sb) || bdev_read_only(sb->s_bdev)) {
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002397 set_sbi_flag(sbi, SBI_NEED_SB_WRITE);
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002398 res = "internally";
2399 } else {
2400 err = __f2fs_commit_super(bh, NULL);
2401 res = err ? "failed" : "done";
2402 }
2403 f2fs_msg(sb, KERN_INFO,
2404 "Fix alignment : %s, start(%u) end(%u) block(%u)",
2405 res, main_blkaddr,
2406 segment0_blkaddr +
2407 (segment_count << log_blocks_per_seg),
2408 segment_count_main << log_blocks_per_seg);
2409 if (err)
2410 return true;
2411 }
Chao Yu9a59b622015-12-15 09:58:18 +08002412 return false;
2413}
2414
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002415static int sanity_check_raw_super(struct f2fs_sb_info *sbi,
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002416 struct buffer_head *bh)
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002417{
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002418 block_t segment_count, segs_per_sec, secs_per_zone;
2419 block_t total_sections, blocks_per_seg;
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002420 struct f2fs_super_block *raw_super = (struct f2fs_super_block *)
2421 (bh->b_data + F2FS_SUPER_OFFSET);
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002422 struct super_block *sb = sbi->sb;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002423 unsigned int blocksize;
Junling Zhengd440c522018-09-28 20:25:56 +08002424 size_t crc_offset = 0;
2425 __u32 crc = 0;
2426
2427 /* Check checksum_offset and crc in superblock */
Chao Yu7beb01f2018-10-24 18:34:26 +08002428 if (__F2FS_HAS_FEATURE(raw_super, F2FS_FEATURE_SB_CHKSUM)) {
Junling Zhengd440c522018-09-28 20:25:56 +08002429 crc_offset = le32_to_cpu(raw_super->checksum_offset);
2430 if (crc_offset !=
2431 offsetof(struct f2fs_super_block, crc)) {
2432 f2fs_msg(sb, KERN_INFO,
2433 "Invalid SB checksum offset: %zu",
2434 crc_offset);
2435 return 1;
2436 }
2437 crc = le32_to_cpu(raw_super->crc);
2438 if (!f2fs_crc_valid(sbi, crc, raw_super, crc_offset)) {
2439 f2fs_msg(sb, KERN_INFO,
2440 "Invalid SB checksum value: %u", crc);
2441 return 1;
2442 }
2443 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002444
Namjae Jeona07ef782012-12-30 14:52:05 +09002445 if (F2FS_SUPER_MAGIC != le32_to_cpu(raw_super->magic)) {
2446 f2fs_msg(sb, KERN_INFO,
2447 "Magic Mismatch, valid(0x%x) - read(0x%x)",
2448 F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic));
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002449 return 1;
Namjae Jeona07ef782012-12-30 14:52:05 +09002450 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002451
majianpeng5c9b4692013-02-01 19:07:57 +08002452 /* Currently, support only 4KB page cache size */
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002453 if (F2FS_BLKSIZE != PAGE_SIZE) {
majianpeng5c9b4692013-02-01 19:07:57 +08002454 f2fs_msg(sb, KERN_INFO,
majianpeng14d7e9d2013-02-01 19:07:03 +08002455 "Invalid page_cache_size (%lu), supports only 4KB\n",
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002456 PAGE_SIZE);
majianpeng5c9b4692013-02-01 19:07:57 +08002457 return 1;
2458 }
2459
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002460 /* Currently, support only 4KB block size */
2461 blocksize = 1 << le32_to_cpu(raw_super->log_blocksize);
majianpeng5c9b4692013-02-01 19:07:57 +08002462 if (blocksize != F2FS_BLKSIZE) {
Namjae Jeona07ef782012-12-30 14:52:05 +09002463 f2fs_msg(sb, KERN_INFO,
2464 "Invalid blocksize (%u), supports only 4KB\n",
2465 blocksize);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002466 return 1;
Namjae Jeona07ef782012-12-30 14:52:05 +09002467 }
majianpeng5c9b4692013-02-01 19:07:57 +08002468
Chao Yu9a59b622015-12-15 09:58:18 +08002469 /* check log blocks per segment */
2470 if (le32_to_cpu(raw_super->log_blocks_per_seg) != 9) {
2471 f2fs_msg(sb, KERN_INFO,
2472 "Invalid log blocks per segment (%u)\n",
2473 le32_to_cpu(raw_super->log_blocks_per_seg));
2474 return 1;
2475 }
2476
Chao Yu55cf9cb2014-09-15 18:01:10 +08002477 /* Currently, support 512/1024/2048/4096 bytes sector size */
2478 if (le32_to_cpu(raw_super->log_sectorsize) >
2479 F2FS_MAX_LOG_SECTOR_SIZE ||
2480 le32_to_cpu(raw_super->log_sectorsize) <
2481 F2FS_MIN_LOG_SECTOR_SIZE) {
2482 f2fs_msg(sb, KERN_INFO, "Invalid log sectorsize (%u)",
2483 le32_to_cpu(raw_super->log_sectorsize));
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002484 return 1;
Namjae Jeona07ef782012-12-30 14:52:05 +09002485 }
Chao Yu55cf9cb2014-09-15 18:01:10 +08002486 if (le32_to_cpu(raw_super->log_sectors_per_block) +
2487 le32_to_cpu(raw_super->log_sectorsize) !=
2488 F2FS_MAX_LOG_SECTOR_SIZE) {
2489 f2fs_msg(sb, KERN_INFO,
2490 "Invalid log sectors per block(%u) log sectorsize(%u)",
2491 le32_to_cpu(raw_super->log_sectors_per_block),
2492 le32_to_cpu(raw_super->log_sectorsize));
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002493 return 1;
Namjae Jeona07ef782012-12-30 14:52:05 +09002494 }
Chao Yu9a59b622015-12-15 09:58:18 +08002495
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002496 segment_count = le32_to_cpu(raw_super->segment_count);
2497 segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
2498 secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
2499 total_sections = le32_to_cpu(raw_super->section_count);
2500
2501 /* blocks_per_seg should be 512, given the above check */
2502 blocks_per_seg = 1 << le32_to_cpu(raw_super->log_blocks_per_seg);
2503
2504 if (segment_count > F2FS_MAX_SEGMENT ||
2505 segment_count < F2FS_MIN_SEGMENTS) {
2506 f2fs_msg(sb, KERN_INFO,
2507 "Invalid segment count (%u)",
2508 segment_count);
2509 return 1;
2510 }
2511
2512 if (total_sections > segment_count ||
2513 total_sections < F2FS_MIN_SEGMENTS ||
2514 segs_per_sec > segment_count || !segs_per_sec) {
2515 f2fs_msg(sb, KERN_INFO,
2516 "Invalid segment/section count (%u, %u x %u)",
2517 segment_count, total_sections, segs_per_sec);
2518 return 1;
2519 }
2520
2521 if ((segment_count / segs_per_sec) < total_sections) {
2522 f2fs_msg(sb, KERN_INFO,
2523 "Small segment_count (%u < %u * %u)",
2524 segment_count, segs_per_sec, total_sections);
2525 return 1;
2526 }
2527
Martin Blumenstingl88960062018-12-22 11:22:26 +01002528 if (segment_count > (le64_to_cpu(raw_super->block_count) >> 9)) {
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002529 f2fs_msg(sb, KERN_INFO,
Martin Blumenstingl88960062018-12-22 11:22:26 +01002530 "Wrong segment_count / block_count (%u > %llu)",
2531 segment_count, le64_to_cpu(raw_super->block_count));
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002532 return 1;
2533 }
2534
Chao Yu42bf5462018-06-23 00:12:36 +08002535 if (secs_per_zone > total_sections || !secs_per_zone) {
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002536 f2fs_msg(sb, KERN_INFO,
Chao Yu42bf5462018-06-23 00:12:36 +08002537 "Wrong secs_per_zone / total_sections (%u, %u)",
Jaegeuk Kim0cfe75c2018-04-27 19:03:22 -07002538 secs_per_zone, total_sections);
2539 return 1;
2540 }
2541 if (le32_to_cpu(raw_super->extension_count) > F2FS_MAX_EXTENSION ||
2542 raw_super->hot_ext_count > F2FS_MAX_EXTENSION ||
2543 (le32_to_cpu(raw_super->extension_count) +
2544 raw_super->hot_ext_count) > F2FS_MAX_EXTENSION) {
2545 f2fs_msg(sb, KERN_INFO,
2546 "Corrupted extension count (%u + %u > %u)",
2547 le32_to_cpu(raw_super->extension_count),
2548 raw_super->hot_ext_count,
2549 F2FS_MAX_EXTENSION);
2550 return 1;
2551 }
2552
2553 if (le32_to_cpu(raw_super->cp_payload) >
2554 (blocks_per_seg - F2FS_CP_PACKS)) {
2555 f2fs_msg(sb, KERN_INFO,
2556 "Insane cp_payload (%u > %u)",
2557 le32_to_cpu(raw_super->cp_payload),
2558 blocks_per_seg - F2FS_CP_PACKS);
2559 return 1;
2560 }
2561
Chao Yu9a59b622015-12-15 09:58:18 +08002562 /* check reserved ino info */
2563 if (le32_to_cpu(raw_super->node_ino) != 1 ||
2564 le32_to_cpu(raw_super->meta_ino) != 2 ||
2565 le32_to_cpu(raw_super->root_ino) != 3) {
2566 f2fs_msg(sb, KERN_INFO,
2567 "Invalid Fs Meta Ino: node(%u) meta(%u) root(%u)",
2568 le32_to_cpu(raw_super->node_ino),
2569 le32_to_cpu(raw_super->meta_ino),
2570 le32_to_cpu(raw_super->root_ino));
2571 return 1;
2572 }
2573
2574 /* check CP/SIT/NAT/SSA/MAIN_AREA area boundary */
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002575 if (sanity_check_area_boundary(sbi, bh))
Chao Yu9a59b622015-12-15 09:58:18 +08002576 return 1;
2577
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002578 return 0;
2579}
2580
Chao Yu4d57b862018-05-30 00:20:41 +08002581int f2fs_sanity_check_ckpt(struct f2fs_sb_info *sbi)
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002582{
2583 unsigned int total, fsmeta;
Jaegeuk Kim577e3492013-01-24 19:56:11 +09002584 struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
2585 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
Jaegeuk Kim2040fce82016-12-05 13:56:04 -08002586 unsigned int ovp_segments, reserved_segments;
Jin Qian15d30422017-05-15 10:45:08 -07002587 unsigned int main_segs, blocks_per_seg;
Chao Yuc77ec612018-06-23 11:25:19 +08002588 unsigned int sit_segs, nat_segs;
2589 unsigned int sit_bitmap_size, nat_bitmap_size;
2590 unsigned int log_blocks_per_seg;
Chao Yu9dc956b2018-06-27 18:05:54 +08002591 unsigned int segment_count_main;
Chao Yue494c2f2018-08-01 19:16:11 +08002592 unsigned int cp_pack_start_sum, cp_payload;
Chao Yu9dc956b2018-06-27 18:05:54 +08002593 block_t user_block_count;
Chao Yu042be0f2018-09-06 20:34:12 +08002594 int i, j;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002595
2596 total = le32_to_cpu(raw_super->segment_count);
2597 fsmeta = le32_to_cpu(raw_super->segment_count_ckpt);
Chao Yuc77ec612018-06-23 11:25:19 +08002598 sit_segs = le32_to_cpu(raw_super->segment_count_sit);
2599 fsmeta += sit_segs;
2600 nat_segs = le32_to_cpu(raw_super->segment_count_nat);
2601 fsmeta += nat_segs;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002602 fsmeta += le32_to_cpu(ckpt->rsvd_segment_count);
2603 fsmeta += le32_to_cpu(raw_super->segment_count_ssa);
2604
Jaegeuk Kim6bacf522013-12-06 15:00:58 +09002605 if (unlikely(fsmeta >= total))
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002606 return 1;
Jaegeuk Kim577e3492013-01-24 19:56:11 +09002607
Jaegeuk Kim2040fce82016-12-05 13:56:04 -08002608 ovp_segments = le32_to_cpu(ckpt->overprov_segment_count);
2609 reserved_segments = le32_to_cpu(ckpt->rsvd_segment_count);
2610
2611 if (unlikely(fsmeta < F2FS_MIN_SEGMENTS ||
2612 ovp_segments == 0 || reserved_segments == 0)) {
2613 f2fs_msg(sbi->sb, KERN_ERR,
2614 "Wrong layout: check mkfs.f2fs version");
2615 return 1;
2616 }
2617
Chao Yu9dc956b2018-06-27 18:05:54 +08002618 user_block_count = le64_to_cpu(ckpt->user_block_count);
2619 segment_count_main = le32_to_cpu(raw_super->segment_count_main);
2620 log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
2621 if (!user_block_count || user_block_count >=
2622 segment_count_main << log_blocks_per_seg) {
2623 f2fs_msg(sbi->sb, KERN_ERR,
2624 "Wrong user_block_count: %u", user_block_count);
2625 return 1;
2626 }
2627
Jin Qian15d30422017-05-15 10:45:08 -07002628 main_segs = le32_to_cpu(raw_super->segment_count_main);
2629 blocks_per_seg = sbi->blocks_per_seg;
2630
2631 for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
2632 if (le32_to_cpu(ckpt->cur_node_segno[i]) >= main_segs ||
2633 le16_to_cpu(ckpt->cur_node_blkoff[i]) >= blocks_per_seg)
2634 return 1;
Chao Yu042be0f2018-09-06 20:34:12 +08002635 for (j = i + 1; j < NR_CURSEG_NODE_TYPE; j++) {
2636 if (le32_to_cpu(ckpt->cur_node_segno[i]) ==
2637 le32_to_cpu(ckpt->cur_node_segno[j])) {
2638 f2fs_msg(sbi->sb, KERN_ERR,
2639 "Node segment (%u, %u) has the same "
2640 "segno: %u", i, j,
2641 le32_to_cpu(ckpt->cur_node_segno[i]));
2642 return 1;
2643 }
2644 }
Jin Qian15d30422017-05-15 10:45:08 -07002645 }
2646 for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) {
2647 if (le32_to_cpu(ckpt->cur_data_segno[i]) >= main_segs ||
2648 le16_to_cpu(ckpt->cur_data_blkoff[i]) >= blocks_per_seg)
2649 return 1;
Chao Yu042be0f2018-09-06 20:34:12 +08002650 for (j = i + 1; j < NR_CURSEG_DATA_TYPE; j++) {
2651 if (le32_to_cpu(ckpt->cur_data_segno[i]) ==
2652 le32_to_cpu(ckpt->cur_data_segno[j])) {
2653 f2fs_msg(sbi->sb, KERN_ERR,
2654 "Data segment (%u, %u) has the same "
2655 "segno: %u", i, j,
2656 le32_to_cpu(ckpt->cur_data_segno[i]));
2657 return 1;
2658 }
2659 }
2660 }
2661 for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
2662 for (j = i; j < NR_CURSEG_DATA_TYPE; j++) {
2663 if (le32_to_cpu(ckpt->cur_node_segno[i]) ==
2664 le32_to_cpu(ckpt->cur_data_segno[j])) {
2665 f2fs_msg(sbi->sb, KERN_ERR,
2666 "Data segment (%u) and Data segment (%u)"
2667 " has the same segno: %u", i, j,
2668 le32_to_cpu(ckpt->cur_node_segno[i]));
2669 return 1;
2670 }
2671 }
Jin Qian15d30422017-05-15 10:45:08 -07002672 }
2673
Chao Yuc77ec612018-06-23 11:25:19 +08002674 sit_bitmap_size = le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);
2675 nat_bitmap_size = le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);
Chao Yuc77ec612018-06-23 11:25:19 +08002676
2677 if (sit_bitmap_size != ((sit_segs / 2) << log_blocks_per_seg) / 8 ||
2678 nat_bitmap_size != ((nat_segs / 2) << log_blocks_per_seg) / 8) {
2679 f2fs_msg(sbi->sb, KERN_ERR,
2680 "Wrong bitmap size: sit: %u, nat:%u",
2681 sit_bitmap_size, nat_bitmap_size);
2682 return 1;
2683 }
2684
Chao Yue494c2f2018-08-01 19:16:11 +08002685 cp_pack_start_sum = __start_sum_addr(sbi);
2686 cp_payload = __cp_payload(sbi);
2687 if (cp_pack_start_sum < cp_payload + 1 ||
2688 cp_pack_start_sum > blocks_per_seg - 1 -
2689 NR_CURSEG_TYPE) {
2690 f2fs_msg(sbi->sb, KERN_ERR,
2691 "Wrong cp_pack_start_sum: %u",
2692 cp_pack_start_sum);
2693 return 1;
2694 }
2695
Jaegeuk Kim1e968fd2014-08-11 16:49:25 -07002696 if (unlikely(f2fs_cp_error(sbi))) {
Jaegeuk Kim577e3492013-01-24 19:56:11 +09002697 f2fs_msg(sbi->sb, KERN_ERR, "A bug case: need to run fsck");
2698 return 1;
2699 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002700 return 0;
2701}
2702
2703static void init_sb_info(struct f2fs_sb_info *sbi)
2704{
2705 struct f2fs_super_block *raw_super = sbi->raw_super;
Yunlong Song089842d2018-10-24 16:09:42 +08002706 int i;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002707
2708 sbi->log_sectors_per_block =
2709 le32_to_cpu(raw_super->log_sectors_per_block);
2710 sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize);
2711 sbi->blocksize = 1 << sbi->log_blocksize;
2712 sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
2713 sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg;
2714 sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
2715 sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
2716 sbi->total_sections = le32_to_cpu(raw_super->section_count);
2717 sbi->total_node_count =
2718 (le32_to_cpu(raw_super->segment_count_nat) / 2)
2719 * sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK;
2720 sbi->root_ino_num = le32_to_cpu(raw_super->root_ino);
2721 sbi->node_ino_num = le32_to_cpu(raw_super->node_ino);
2722 sbi->meta_ino_num = le32_to_cpu(raw_super->meta_ino);
Jaegeuk Kim5ec4e492013-03-31 13:26:03 +09002723 sbi->cur_victim_sec = NULL_SECNO;
Chao Yue3080b02018-10-24 18:37:27 +08002724 sbi->next_victim_seg[BG_GC] = NULL_SEGNO;
2725 sbi->next_victim_seg[FG_GC] = NULL_SEGNO;
Jaegeuk Kimb1c57c12014-01-08 13:45:08 +09002726 sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH;
Chao Yue3080b02018-10-24 18:37:27 +08002727 sbi->migration_granularity = sbi->segs_per_sec;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002728
Jaegeuk Kimab9fa662014-02-27 20:09:05 +09002729 sbi->dir_level = DEF_DIR_LEVEL;
Jaegeuk Kim6beceb52016-01-08 15:51:50 -08002730 sbi->interval_time[CP_TIME] = DEF_CP_INTERVAL;
Jaegeuk Kimd0239e12016-01-08 16:57:48 -08002731 sbi->interval_time[REQ_TIME] = DEF_IDLE_INTERVAL;
Sahitya Tummalaa7d10cf2018-09-19 14:18:47 +05302732 sbi->interval_time[DISCARD_TIME] = DEF_IDLE_INTERVAL;
2733 sbi->interval_time[GC_TIME] = DEF_IDLE_INTERVAL;
Daniel Rosenberg43549942018-08-20 19:21:43 -07002734 sbi->interval_time[DISABLE_TIME] = DEF_DISABLE_INTERVAL;
Jaegeuk Kim03f2c022019-01-14 10:42:11 -08002735 sbi->interval_time[UMOUNT_DISCARD_TIMEOUT] =
2736 DEF_UMOUNT_DISCARD_TIMEOUT;
Chao Yucaf00472015-01-28 17:48:42 +08002737 clear_sbi_flag(sbi, SBI_NEED_FSCK);
Jaegeuk Kim2658e502015-06-19 12:01:21 -07002738
Jaegeuk Kim35782b22016-10-20 19:09:57 -07002739 for (i = 0; i < NR_COUNT_TYPE; i++)
2740 atomic_set(&sbi->nr_pages[i], 0);
2741
Chao Yuc29fd0c2018-06-04 23:20:36 +08002742 for (i = 0; i < META; i++)
2743 atomic_set(&sbi->wb_sync_req[i], 0);
Jaegeuk Kim687de7f2017-03-28 18:07:38 -07002744
Jaegeuk Kim2658e502015-06-19 12:01:21 -07002745 INIT_LIST_HEAD(&sbi->s_list);
2746 mutex_init(&sbi->umount_mutex);
Chao Yu107a8052018-05-26 09:00:13 +08002747 init_rwsem(&sbi->io_order_lock);
Chao Yuaaec2b12016-09-20 11:04:18 +08002748 spin_lock_init(&sbi->cp_lock);
Chao Yu1228b482017-09-29 13:59:39 +08002749
2750 sbi->dirty_device = 0;
2751 spin_lock_init(&sbi->dev_lock);
Chao Yud0d3f1b2018-02-11 22:53:20 +08002752
Chao Yu846ae672018-02-26 22:04:13 +08002753 init_rwsem(&sbi->sb_lock);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09002754}
2755
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07002756static int init_percpu_info(struct f2fs_sb_info *sbi)
2757{
Jaegeuk Kim35782b22016-10-20 19:09:57 -07002758 int err;
Jaegeuk Kim41382ec2016-05-16 11:06:50 -07002759
Jaegeuk Kim513c5f32016-05-16 11:42:32 -07002760 err = percpu_counter_init(&sbi->alloc_valid_block_count, 0, GFP_KERNEL);
2761 if (err)
2762 return err;
2763
Chao Yu4a70e252018-09-05 14:54:02 +08002764 err = percpu_counter_init(&sbi->total_valid_inode_count, 0,
Jaegeuk Kim41382ec2016-05-16 11:06:50 -07002765 GFP_KERNEL);
Chao Yu4a70e252018-09-05 14:54:02 +08002766 if (err)
2767 percpu_counter_destroy(&sbi->alloc_valid_block_count);
2768
2769 return err;
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07002770}
2771
Damien Le Moal178053e2016-10-28 17:45:05 +09002772#ifdef CONFIG_BLK_DEV_ZONED
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002773static int init_blkz_info(struct f2fs_sb_info *sbi, int devi)
Damien Le Moal178053e2016-10-28 17:45:05 +09002774{
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002775 struct block_device *bdev = FDEV(devi).bdev;
Damien Le Moal178053e2016-10-28 17:45:05 +09002776 sector_t nr_sectors = bdev->bd_part->nr_sects;
2777 sector_t sector = 0;
2778 struct blk_zone *zones;
2779 unsigned int i, nr_zones;
2780 unsigned int n = 0;
2781 int err = -EIO;
2782
Chao Yu7beb01f2018-10-24 18:34:26 +08002783 if (!f2fs_sb_has_blkzoned(sbi))
Damien Le Moal178053e2016-10-28 17:45:05 +09002784 return 0;
2785
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002786 if (sbi->blocks_per_blkz && sbi->blocks_per_blkz !=
Damien Le Moalf99e8642017-01-12 07:58:32 -07002787 SECTOR_TO_BLOCK(bdev_zone_sectors(bdev)))
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002788 return -EINVAL;
Damien Le Moalf99e8642017-01-12 07:58:32 -07002789 sbi->blocks_per_blkz = SECTOR_TO_BLOCK(bdev_zone_sectors(bdev));
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002790 if (sbi->log_blocks_per_blkz && sbi->log_blocks_per_blkz !=
2791 __ilog2_u32(sbi->blocks_per_blkz))
2792 return -EINVAL;
Damien Le Moal178053e2016-10-28 17:45:05 +09002793 sbi->log_blocks_per_blkz = __ilog2_u32(sbi->blocks_per_blkz);
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002794 FDEV(devi).nr_blkz = SECTOR_TO_BLOCK(nr_sectors) >>
2795 sbi->log_blocks_per_blkz;
Damien Le Moalf99e8642017-01-12 07:58:32 -07002796 if (nr_sectors & (bdev_zone_sectors(bdev) - 1))
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002797 FDEV(devi).nr_blkz++;
Damien Le Moal178053e2016-10-28 17:45:05 +09002798
Chao Yu4e6aad22017-11-30 19:28:19 +08002799 FDEV(devi).blkz_type = f2fs_kmalloc(sbi, FDEV(devi).nr_blkz,
2800 GFP_KERNEL);
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002801 if (!FDEV(devi).blkz_type)
Damien Le Moal178053e2016-10-28 17:45:05 +09002802 return -ENOMEM;
2803
2804#define F2FS_REPORT_NR_ZONES 4096
2805
Kees Cook026f0502018-06-12 14:28:23 -07002806 zones = f2fs_kzalloc(sbi,
2807 array_size(F2FS_REPORT_NR_ZONES,
2808 sizeof(struct blk_zone)),
2809 GFP_KERNEL);
Damien Le Moal178053e2016-10-28 17:45:05 +09002810 if (!zones)
2811 return -ENOMEM;
2812
2813 /* Get block zones type */
2814 while (zones && sector < nr_sectors) {
2815
2816 nr_zones = F2FS_REPORT_NR_ZONES;
2817 err = blkdev_report_zones(bdev, sector,
2818 zones, &nr_zones,
2819 GFP_KERNEL);
2820 if (err)
2821 break;
2822 if (!nr_zones) {
2823 err = -EIO;
2824 break;
2825 }
2826
2827 for (i = 0; i < nr_zones; i++) {
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002828 FDEV(devi).blkz_type[n] = zones[i].type;
Damien Le Moal178053e2016-10-28 17:45:05 +09002829 sector += zones[i].len;
2830 n++;
2831 }
2832 }
2833
Jaegeuk Kim52225952018-12-13 18:38:33 -08002834 kvfree(zones);
Damien Le Moal178053e2016-10-28 17:45:05 +09002835
2836 return err;
2837}
2838#endif
2839
Gu Zheng9076a752013-10-14 18:47:11 +08002840/*
2841 * Read f2fs raw super block.
Shawn Lin2b39e902016-02-17 08:59:01 +08002842 * Because we have two copies of super block, so read both of them
2843 * to get the first valid one. If any one of them is broken, we pass
2844 * them recovery flag back to the caller.
Gu Zheng9076a752013-10-14 18:47:11 +08002845 */
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002846static int read_raw_super_block(struct f2fs_sb_info *sbi,
Gu Zheng9076a752013-10-14 18:47:11 +08002847 struct f2fs_super_block **raw_super,
Chao Yue8240f62015-12-15 17:19:26 +08002848 int *valid_super_block, int *recovery)
majianpeng14d7e9d2013-02-01 19:07:03 +08002849{
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002850 struct super_block *sb = sbi->sb;
Shawn Lin2b39e902016-02-17 08:59:01 +08002851 int block;
Chao Yue8240f62015-12-15 17:19:26 +08002852 struct buffer_head *bh;
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002853 struct f2fs_super_block *super;
hujianyangda554e42015-05-21 14:42:53 +08002854 int err = 0;
majianpeng14d7e9d2013-02-01 19:07:03 +08002855
Yunlei Heb39f0de2015-12-15 17:17:20 +08002856 super = kzalloc(sizeof(struct f2fs_super_block), GFP_KERNEL);
2857 if (!super)
2858 return -ENOMEM;
Shawn Lin2b39e902016-02-17 08:59:01 +08002859
2860 for (block = 0; block < 2; block++) {
2861 bh = sb_bread(sb, block);
2862 if (!bh) {
2863 f2fs_msg(sb, KERN_ERR, "Unable to read %dth superblock",
Gu Zheng9076a752013-10-14 18:47:11 +08002864 block + 1);
Shawn Lin2b39e902016-02-17 08:59:01 +08002865 err = -EIO;
2866 continue;
2867 }
majianpeng14d7e9d2013-02-01 19:07:03 +08002868
Shawn Lin2b39e902016-02-17 08:59:01 +08002869 /* sanity checking of raw super */
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002870 if (sanity_check_raw_super(sbi, bh)) {
Shawn Lin2b39e902016-02-17 08:59:01 +08002871 f2fs_msg(sb, KERN_ERR,
2872 "Can't find valid F2FS filesystem in %dth superblock",
2873 block + 1);
2874 err = -EINVAL;
2875 brelse(bh);
2876 continue;
2877 }
2878
2879 if (!*raw_super) {
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002880 memcpy(super, bh->b_data + F2FS_SUPER_OFFSET,
2881 sizeof(*super));
Shawn Lin2b39e902016-02-17 08:59:01 +08002882 *valid_super_block = block;
2883 *raw_super = super;
2884 }
Chao Yue8240f62015-12-15 17:19:26 +08002885 brelse(bh);
Shawn Lin2b39e902016-02-17 08:59:01 +08002886 }
2887
2888 /* Fail to read any one of the superblocks*/
2889 if (err < 0)
hujianyangda554e42015-05-21 14:42:53 +08002890 *recovery = 1;
hujianyangda554e42015-05-21 14:42:53 +08002891
hujianyangda554e42015-05-21 14:42:53 +08002892 /* No valid superblock */
Shawn Lin2b39e902016-02-17 08:59:01 +08002893 if (!*raw_super)
Jaegeuk Kim52225952018-12-13 18:38:33 -08002894 kvfree(super);
Shawn Lin2b39e902016-02-17 08:59:01 +08002895 else
2896 err = 0;
hujianyangda554e42015-05-21 14:42:53 +08002897
Shawn Lin2b39e902016-02-17 08:59:01 +08002898 return err;
majianpeng14d7e9d2013-02-01 19:07:03 +08002899}
2900
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002901int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover)
Jaegeuk Kim26d815ad2015-04-20 18:49:51 -07002902{
Jaegeuk Kim5d909cd2015-12-07 10:16:58 -08002903 struct buffer_head *bh;
Junling Zhengd440c522018-09-28 20:25:56 +08002904 __u32 crc = 0;
Jaegeuk Kim26d815ad2015-04-20 18:49:51 -07002905 int err;
2906
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002907 if ((recover && f2fs_readonly(sbi->sb)) ||
2908 bdev_read_only(sbi->sb->s_bdev)) {
2909 set_sbi_flag(sbi, SBI_NEED_SB_WRITE);
Jaegeuk Kimf2353d72016-03-23 10:42:01 -07002910 return -EROFS;
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07002911 }
Jaegeuk Kimf2353d72016-03-23 10:42:01 -07002912
Junling Zhengd440c522018-09-28 20:25:56 +08002913 /* we should update superblock crc here */
Chao Yu7beb01f2018-10-24 18:34:26 +08002914 if (!recover && f2fs_sb_has_sb_chksum(sbi)) {
Junling Zhengd440c522018-09-28 20:25:56 +08002915 crc = f2fs_crc32(sbi, F2FS_RAW_SUPER(sbi),
2916 offsetof(struct f2fs_super_block, crc));
2917 F2FS_RAW_SUPER(sbi)->crc = cpu_to_le32(crc);
2918 }
2919
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002920 /* write back-up superblock first */
Sheng Yong0964fc12018-01-29 19:13:15 +08002921 bh = sb_bread(sbi->sb, sbi->valid_super_block ? 0 : 1);
Jaegeuk Kim5d909cd2015-12-07 10:16:58 -08002922 if (!bh)
2923 return -EIO;
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002924 err = __f2fs_commit_super(bh, F2FS_RAW_SUPER(sbi));
Jaegeuk Kim5d909cd2015-12-07 10:16:58 -08002925 brelse(bh);
Chao Yuc5bda1c2015-06-08 13:28:03 +08002926
2927 /* if we are in recovery path, skip writing valid superblock */
2928 if (recover || err)
Jaegeuk Kim5d909cd2015-12-07 10:16:58 -08002929 return err;
Jaegeuk Kim26d815ad2015-04-20 18:49:51 -07002930
Chao Yue8240f62015-12-15 17:19:26 +08002931 /* write current valid superblock */
Sheng Yong0964fc12018-01-29 19:13:15 +08002932 bh = sb_bread(sbi->sb, sbi->valid_super_block);
Jaegeuk Kimfd694732016-03-20 15:33:20 -07002933 if (!bh)
2934 return -EIO;
2935 err = __f2fs_commit_super(bh, F2FS_RAW_SUPER(sbi));
2936 brelse(bh);
2937 return err;
Jaegeuk Kim26d815ad2015-04-20 18:49:51 -07002938}
2939
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002940static int f2fs_scan_devices(struct f2fs_sb_info *sbi)
2941{
2942 struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
Masato Suzuki7bb3a372017-02-27 20:52:49 +09002943 unsigned int max_devices = MAX_DEVICES;
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002944 int i;
2945
Masato Suzuki7bb3a372017-02-27 20:52:49 +09002946 /* Initialize single device information */
2947 if (!RDEV(0).path[0]) {
2948 if (!bdev_is_zoned(sbi->sb->s_bdev))
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002949 return 0;
Masato Suzuki7bb3a372017-02-27 20:52:49 +09002950 max_devices = 1;
2951 }
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002952
Masato Suzuki7bb3a372017-02-27 20:52:49 +09002953 /*
2954 * Initialize multiple devices information, or single
2955 * zoned block device information.
2956 */
Kees Cook026f0502018-06-12 14:28:23 -07002957 sbi->devs = f2fs_kzalloc(sbi,
2958 array_size(max_devices,
2959 sizeof(struct f2fs_dev_info)),
2960 GFP_KERNEL);
Masato Suzuki7bb3a372017-02-27 20:52:49 +09002961 if (!sbi->devs)
2962 return -ENOMEM;
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002963
Masato Suzuki7bb3a372017-02-27 20:52:49 +09002964 for (i = 0; i < max_devices; i++) {
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002965
Masato Suzuki7bb3a372017-02-27 20:52:49 +09002966 if (i > 0 && !RDEV(i).path[0])
2967 break;
2968
2969 if (max_devices == 1) {
2970 /* Single zoned block device mount */
2971 FDEV(0).bdev =
2972 blkdev_get_by_dev(sbi->sb->s_bdev->bd_dev,
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002973 sbi->sb->s_mode, sbi->sb->s_type);
Masato Suzuki7bb3a372017-02-27 20:52:49 +09002974 } else {
2975 /* Multi-device mount */
2976 memcpy(FDEV(i).path, RDEV(i).path, MAX_PATH_LEN);
2977 FDEV(i).total_segments =
2978 le32_to_cpu(RDEV(i).total_segments);
2979 if (i == 0) {
2980 FDEV(i).start_blk = 0;
2981 FDEV(i).end_blk = FDEV(i).start_blk +
2982 (FDEV(i).total_segments <<
2983 sbi->log_blocks_per_seg) - 1 +
2984 le32_to_cpu(raw_super->segment0_blkaddr);
2985 } else {
2986 FDEV(i).start_blk = FDEV(i - 1).end_blk + 1;
2987 FDEV(i).end_blk = FDEV(i).start_blk +
2988 (FDEV(i).total_segments <<
2989 sbi->log_blocks_per_seg) - 1;
2990 }
2991 FDEV(i).bdev = blkdev_get_by_path(FDEV(i).path,
2992 sbi->sb->s_mode, sbi->sb->s_type);
2993 }
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07002994 if (IS_ERR(FDEV(i).bdev))
2995 return PTR_ERR(FDEV(i).bdev);
2996
2997 /* to release errored devices */
2998 sbi->s_ndevs = i + 1;
2999
3000#ifdef CONFIG_BLK_DEV_ZONED
3001 if (bdev_zoned_model(FDEV(i).bdev) == BLK_ZONED_HM &&
Chao Yu7beb01f2018-10-24 18:34:26 +08003002 !f2fs_sb_has_blkzoned(sbi)) {
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003003 f2fs_msg(sbi->sb, KERN_ERR,
3004 "Zoned block device feature not enabled\n");
3005 return -EINVAL;
3006 }
3007 if (bdev_zoned_model(FDEV(i).bdev) != BLK_ZONED_NONE) {
3008 if (init_blkz_info(sbi, i)) {
3009 f2fs_msg(sbi->sb, KERN_ERR,
3010 "Failed to initialize F2FS blkzone information");
3011 return -EINVAL;
3012 }
Masato Suzuki7bb3a372017-02-27 20:52:49 +09003013 if (max_devices == 1)
3014 break;
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003015 f2fs_msg(sbi->sb, KERN_INFO,
3016 "Mount Device [%2d]: %20s, %8u, %8x - %8x (zone: %s)",
3017 i, FDEV(i).path,
3018 FDEV(i).total_segments,
3019 FDEV(i).start_blk, FDEV(i).end_blk,
3020 bdev_zoned_model(FDEV(i).bdev) == BLK_ZONED_HA ?
3021 "Host-aware" : "Host-managed");
3022 continue;
3023 }
3024#endif
3025 f2fs_msg(sbi->sb, KERN_INFO,
3026 "Mount Device [%2d]: %20s, %8u, %8x - %8x",
3027 i, FDEV(i).path,
3028 FDEV(i).total_segments,
3029 FDEV(i).start_blk, FDEV(i).end_blk);
3030 }
Jaegeuk Kim0a595eb2016-12-14 10:12:56 -08003031 f2fs_msg(sbi->sb, KERN_INFO,
3032 "IO Block Size: %8d KB", F2FS_IO_SIZE_KB(sbi));
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003033 return 0;
3034}
3035
Jaegeuk Kim84b89e52018-02-22 14:09:30 -08003036static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
3037{
3038 struct f2fs_sm_info *sm_i = SM_I(sbi);
3039
3040 /* adjust parameters according to the volume size */
3041 if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
Chao Yu63189b72018-03-08 14:22:56 +08003042 F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
Jaegeuk Kim84b89e52018-02-22 14:09:30 -08003043 sm_i->dcc_info->discard_granularity = 1;
3044 sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
3045 }
Chao Yu4cac90d2018-06-11 18:02:01 +08003046
3047 sbi->readdir_ra = 1;
Jaegeuk Kim84b89e52018-02-22 14:09:30 -08003048}
3049
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003050static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
3051{
3052 struct f2fs_sb_info *sbi;
hujianyangda554e42015-05-21 14:42:53 +08003053 struct f2fs_super_block *raw_super;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003054 struct inode *root;
Sheng Yong99e3e852016-05-11 17:08:14 +08003055 int err;
Chao Yuaa2c8c42019-02-19 16:23:53 +08003056 bool skip_recovery = false, need_fsck = false;
Jaegeuk Kimdabc4a52015-01-23 17:41:39 -08003057 char *options = NULL;
Chao Yue8240f62015-12-15 17:19:26 +08003058 int recovery, i, valid_super_block;
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08003059 struct curseg_info *seg_i;
Chao Yuaa2c8c42019-02-19 16:23:53 +08003060 int retry_cnt = 1;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003061
Jaegeuk Kimed2e6212014-08-08 15:37:41 -07003062try_onemore:
hujianyangda554e42015-05-21 14:42:53 +08003063 err = -EINVAL;
3064 raw_super = NULL;
Chao Yue8240f62015-12-15 17:19:26 +08003065 valid_super_block = -1;
hujianyangda554e42015-05-21 14:42:53 +08003066 recovery = 0;
3067
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003068 /* allocate memory for f2fs-specific super block info */
3069 sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
3070 if (!sbi)
3071 return -ENOMEM;
3072
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07003073 sbi->sb = sb;
3074
Keith Mok43b65732016-03-02 12:04:24 -08003075 /* Load the checksum driver */
3076 sbi->s_chksum_driver = crypto_alloc_shash("crc32", 0, 0);
3077 if (IS_ERR(sbi->s_chksum_driver)) {
3078 f2fs_msg(sb, KERN_ERR, "Cannot load crc32 driver.");
3079 err = PTR_ERR(sbi->s_chksum_driver);
3080 sbi->s_chksum_driver = NULL;
3081 goto free_sbi;
3082 }
3083
Namjae Jeonff9234a2013-01-12 14:41:13 +09003084 /* set a block size */
Jaegeuk Kim6bacf522013-12-06 15:00:58 +09003085 if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) {
Namjae Jeona07ef782012-12-30 14:52:05 +09003086 f2fs_msg(sb, KERN_ERR, "unable to set blocksize");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003087 goto free_sbi;
Namjae Jeona07ef782012-12-30 14:52:05 +09003088 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003089
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07003090 err = read_raw_super_block(sbi, &raw_super, &valid_super_block,
Chao Yue8240f62015-12-15 17:19:26 +08003091 &recovery);
Gu Zheng9076a752013-10-14 18:47:11 +08003092 if (err)
3093 goto free_sbi;
3094
Gu Zheng5fb08372013-06-07 14:16:53 +08003095 sb->s_fs_info = sbi;
Jaegeuk Kim52763a42016-06-13 09:47:48 -07003096 sbi->raw_super = raw_super;
3097
Chao Yu704956e2017-07-31 20:19:09 +08003098 /* precompute checksum seed for metadata */
Chao Yu7beb01f2018-10-24 18:34:26 +08003099 if (f2fs_sb_has_inode_chksum(sbi))
Chao Yu704956e2017-07-31 20:19:09 +08003100 sbi->s_chksum_seed = f2fs_chksum(sbi, ~0, raw_super->uuid,
3101 sizeof(raw_super->uuid));
3102
Damien Le Moald1b959c2016-10-28 17:45:01 +09003103 /*
3104 * The BLKZONED feature indicates that the drive was formatted with
3105 * zone alignment optimization. This is optional for host-aware
3106 * devices, but mandatory for host-managed zoned block devices.
3107 */
3108#ifndef CONFIG_BLK_DEV_ZONED
Chao Yu7beb01f2018-10-24 18:34:26 +08003109 if (f2fs_sb_has_blkzoned(sbi)) {
Damien Le Moald1b959c2016-10-28 17:45:01 +09003110 f2fs_msg(sb, KERN_ERR,
3111 "Zoned block device support is not enabled\n");
Chao Yu1727f312017-06-12 09:44:27 +08003112 err = -EOPNOTSUPP;
Damien Le Moald1b959c2016-10-28 17:45:01 +09003113 goto free_sb_buf;
3114 }
Damien Le Moald1b959c2016-10-28 17:45:01 +09003115#endif
Yunlei He498c5e92015-05-07 18:11:37 +08003116 default_options(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003117 /* parse mount options */
Jaegeuk Kimdabc4a52015-01-23 17:41:39 -08003118 options = kstrdup((const char *)data, GFP_KERNEL);
3119 if (data && !options) {
3120 err = -ENOMEM;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003121 goto free_sb_buf;
Jaegeuk Kimdabc4a52015-01-23 17:41:39 -08003122 }
3123
3124 err = parse_options(sb, options);
3125 if (err)
3126 goto free_options;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003127
Chao Yue0afc4d2015-12-31 14:35:37 +08003128 sbi->max_file_blocks = max_file_blocks();
3129 sb->s_maxbytes = sbi->max_file_blocks <<
3130 le32_to_cpu(raw_super->log_blocksize);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003131 sb->s_max_links = F2FS_LINK_MAX;
3132 get_random_bytes(&sbi->s_next_generation, sizeof(u32));
3133
Chao Yu0abd6752017-07-09 00:13:07 +08003134#ifdef CONFIG_QUOTA
3135 sb->dq_op = &f2fs_quota_operations;
Chao Yu7beb01f2018-10-24 18:34:26 +08003136 if (f2fs_sb_has_quota_ino(sbi))
Jaegeuk Kimea676732017-10-06 09:14:28 -07003137 sb->s_qcop = &dquot_quotactl_sysfile_ops;
3138 else
3139 sb->s_qcop = &f2fs_quotactl_ops;
Chao Yu5c571322017-07-26 00:01:41 +08003140 sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;
Chao Yu292c196a2017-11-16 16:59:14 +08003141
Chao Yu7beb01f2018-10-24 18:34:26 +08003142 if (f2fs_sb_has_quota_ino(sbi)) {
Chao Yu292c196a2017-11-16 16:59:14 +08003143 for (i = 0; i < MAXQUOTAS; i++) {
3144 if (f2fs_qf_ino(sbi->sb, i))
3145 sbi->nquota_files++;
3146 }
3147 }
Chao Yu0abd6752017-07-09 00:13:07 +08003148#endif
3149
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003150 sb->s_op = &f2fs_sops;
Eric Biggersffcc41822017-10-09 12:15:38 -07003151#ifdef CONFIG_F2FS_FS_ENCRYPTION
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07003152 sb->s_cop = &f2fs_cryptops;
Eric Biggersffcc41822017-10-09 12:15:38 -07003153#endif
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003154 sb->s_xattr = f2fs_xattr_handlers;
3155 sb->s_export_op = &f2fs_export_ops;
3156 sb->s_magic = F2FS_SUPER_MAGIC;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003157 sb->s_time_gran = 1;
Linus Torvalds1751e8a2017-11-27 13:05:09 -08003158 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
3159 (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
Christoph Hellwig85787092017-05-10 15:06:33 +02003160 memcpy(&sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid));
Yufen Yu578c6472018-01-09 19:33:39 +08003161 sb->s_iflags |= SB_I_CGROUPWB;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003162
3163 /* init f2fs-specific super block info */
Chao Yue8240f62015-12-15 17:19:26 +08003164 sbi->valid_super_block = valid_super_block;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003165 mutex_init(&sbi->gc_mutex);
Jaegeuk Kim853137c2018-08-09 17:53:34 -07003166 mutex_init(&sbi->writepages);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003167 mutex_init(&sbi->cp_mutex);
Chao Yub3582c62014-07-03 18:58:39 +08003168 init_rwsem(&sbi->node_write);
Yunlei He59c90812017-03-13 20:22:18 +08003169 init_rwsem(&sbi->node_change);
Jaegeuk Kim315df832015-08-11 12:45:39 -07003170
3171 /* disallow all the data/node/meta page writes */
3172 set_sbi_flag(sbi, SBI_POR_DOING);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003173 spin_lock_init(&sbi->stat_lock);
Jaegeuk Kim971767c2013-11-18 17:16:17 +09003174
Chao Yub0af6d42017-08-02 23:21:48 +08003175 /* init iostat info */
3176 spin_lock_init(&sbi->iostat_lock);
3177 sbi->iostat_enable = false;
3178
Jaegeuk Kim458e6192013-12-11 13:54:01 +09003179 for (i = 0; i < NR_PAGE_TYPE; i++) {
Jaegeuk Kima912b542017-05-10 11:18:25 -07003180 int n = (i == META) ? 1: NR_TEMP_TYPE;
3181 int j;
3182
Kees Cookc8606592018-06-12 14:28:16 -07003183 sbi->write_io[i] =
3184 f2fs_kmalloc(sbi,
3185 array_size(n,
3186 sizeof(struct f2fs_bio_info)),
3187 GFP_KERNEL);
Christophe JAILLETb63def92017-06-11 09:21:11 +02003188 if (!sbi->write_io[i]) {
3189 err = -ENOMEM;
Chao Yu0b2103e82018-09-05 14:54:01 +08003190 goto free_bio_info;
Christophe JAILLETb63def92017-06-11 09:21:11 +02003191 }
Jaegeuk Kima912b542017-05-10 11:18:25 -07003192
3193 for (j = HOT; j < n; j++) {
3194 init_rwsem(&sbi->write_io[i][j].io_rwsem);
3195 sbi->write_io[i][j].sbi = sbi;
3196 sbi->write_io[i][j].bio = NULL;
Chao Yufb830fc2017-05-19 23:37:01 +08003197 spin_lock_init(&sbi->write_io[i][j].io_lock);
3198 INIT_LIST_HEAD(&sbi->write_io[i][j].io_list);
Jaegeuk Kima912b542017-05-10 11:18:25 -07003199 }
Jaegeuk Kim458e6192013-12-11 13:54:01 +09003200 }
Jaegeuk Kim971767c2013-11-18 17:16:17 +09003201
Jaegeuk Kimb873b792016-08-04 11:38:25 -07003202 init_rwsem(&sbi->cp_rwsem);
Changman Leefb51b5e2013-11-07 12:48:25 +09003203 init_waitqueue_head(&sbi->cp_wait);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003204 init_sb_info(sbi);
3205
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07003206 err = init_percpu_info(sbi);
3207 if (err)
Chao Yud7997e62018-01-17 16:31:35 +08003208 goto free_bio_info;
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07003209
Jaegeuk Kim0a595eb2016-12-14 10:12:56 -08003210 if (F2FS_IO_SIZE(sbi) > 1) {
3211 sbi->write_io_dummy =
Chao Yua3ebfe42017-02-27 18:43:13 +08003212 mempool_create_page_pool(2 * (F2FS_IO_SIZE(sbi) - 1), 0);
Chao Yu1727f312017-06-12 09:44:27 +08003213 if (!sbi->write_io_dummy) {
3214 err = -ENOMEM;
Chao Yud7997e62018-01-17 16:31:35 +08003215 goto free_percpu;
Chao Yu1727f312017-06-12 09:44:27 +08003216 }
Jaegeuk Kim0a595eb2016-12-14 10:12:56 -08003217 }
3218
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003219 /* get an inode for meta space */
3220 sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi));
3221 if (IS_ERR(sbi->meta_inode)) {
Namjae Jeona07ef782012-12-30 14:52:05 +09003222 f2fs_msg(sb, KERN_ERR, "Failed to read F2FS meta data inode");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003223 err = PTR_ERR(sbi->meta_inode);
Jaegeuk Kim0a595eb2016-12-14 10:12:56 -08003224 goto free_io_dummy;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003225 }
3226
Chao Yu4d57b862018-05-30 00:20:41 +08003227 err = f2fs_get_valid_checkpoint(sbi);
Namjae Jeona07ef782012-12-30 14:52:05 +09003228 if (err) {
3229 f2fs_msg(sb, KERN_ERR, "Failed to get valid F2FS checkpoint");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003230 goto free_meta_inode;
Namjae Jeona07ef782012-12-30 14:52:05 +09003231 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003232
Chao Yuaf033b22018-09-20 20:05:00 +08003233 if (__is_set_ckpt_flags(F2FS_CKPT(sbi), CP_QUOTA_NEED_FSCK_FLAG))
3234 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
Jaegeuk Kimdb610a62019-01-24 17:48:38 -08003235 if (__is_set_ckpt_flags(F2FS_CKPT(sbi), CP_DISABLED_QUICK_FLAG)) {
3236 set_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);
3237 sbi->interval_time[DISABLE_TIME] = DEF_DISABLE_QUICK_INTERVAL;
3238 }
Chao Yuaf033b22018-09-20 20:05:00 +08003239
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003240 /* Initialize device list */
3241 err = f2fs_scan_devices(sbi);
3242 if (err) {
3243 f2fs_msg(sb, KERN_ERR, "Failed to find devices");
3244 goto free_devices;
3245 }
3246
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003247 sbi->total_valid_node_count =
3248 le32_to_cpu(sbi->ckpt->valid_node_count);
Jaegeuk Kim513c5f32016-05-16 11:42:32 -07003249 percpu_counter_set(&sbi->total_valid_inode_count,
3250 le32_to_cpu(sbi->ckpt->valid_inode_count));
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003251 sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count);
3252 sbi->total_valid_block_count =
3253 le64_to_cpu(sbi->ckpt->valid_block_count);
3254 sbi->last_valid_block_count = sbi->total_valid_block_count;
Chao Yudaeb4332017-06-26 16:24:41 +08003255 sbi->reserved_blocks = 0;
Yunlong Song80d42142017-10-27 20:45:05 +08003256 sbi->current_reserved_blocks = 0;
Jaegeuk Kim7e65be42017-12-27 15:05:52 -08003257 limit_reserve_root(sbi);
Jaegeuk Kim41382ec2016-05-16 11:06:50 -07003258
Chao Yuc227f912015-12-16 13:09:20 +08003259 for (i = 0; i < NR_INODE_TYPE; i++) {
3260 INIT_LIST_HEAD(&sbi->inode_list[i]);
3261 spin_lock_init(&sbi->inode_lock[i]);
3262 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003263
Chao Yu4d57b862018-05-30 00:20:41 +08003264 f2fs_init_extent_cache_info(sbi);
Chao Yu1dcc3362015-02-05 17:57:31 +08003265
Chao Yu4d57b862018-05-30 00:20:41 +08003266 f2fs_init_ino_entry_info(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003267
Chao Yu50fa53e2018-08-02 23:03:19 +08003268 f2fs_init_fsync_node_info(sbi);
3269
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003270 /* setup f2fs internal modules */
Chao Yu4d57b862018-05-30 00:20:41 +08003271 err = f2fs_build_segment_manager(sbi);
Namjae Jeona07ef782012-12-30 14:52:05 +09003272 if (err) {
3273 f2fs_msg(sb, KERN_ERR,
3274 "Failed to initialize F2FS segment manager");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003275 goto free_sm;
Namjae Jeona07ef782012-12-30 14:52:05 +09003276 }
Chao Yu4d57b862018-05-30 00:20:41 +08003277 err = f2fs_build_node_manager(sbi);
Namjae Jeona07ef782012-12-30 14:52:05 +09003278 if (err) {
3279 f2fs_msg(sb, KERN_ERR,
3280 "Failed to initialize F2FS node manager");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003281 goto free_nm;
Namjae Jeona07ef782012-12-30 14:52:05 +09003282 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003283
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08003284 /* For write statistics */
3285 if (sb->s_bdev->bd_part)
3286 sbi->sectors_written_start =
Michael Callahandbae2c52018-07-18 04:47:38 -07003287 (u64)part_stat_read(sb->s_bdev->bd_part,
3288 sectors[STAT_WRITE]);
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08003289
3290 /* Read accumulated write IO statistics if exists */
3291 seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);
3292 if (__exist_node_summaries(sbi))
3293 sbi->kbytes_written =
Shuoran Liub2dde6f2016-03-29 18:00:15 +08003294 le64_to_cpu(seg_i->journal->info.kbytes_written);
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08003295
Chao Yu4d57b862018-05-30 00:20:41 +08003296 f2fs_build_gc_manager(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003297
Sahitya Tummala60aa4d52018-12-26 11:20:29 +05303298 err = f2fs_build_stats(sbi);
3299 if (err)
3300 goto free_nm;
3301
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003302 /* get an inode for node space */
3303 sbi->node_inode = f2fs_iget(sb, F2FS_NODE_INO(sbi));
3304 if (IS_ERR(sbi->node_inode)) {
Namjae Jeona07ef782012-12-30 14:52:05 +09003305 f2fs_msg(sb, KERN_ERR, "Failed to read node inode");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003306 err = PTR_ERR(sbi->node_inode);
Sahitya Tummala60aa4d52018-12-26 11:20:29 +05303307 goto free_stats;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003308 }
3309
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003310 /* read root inode and dentry */
3311 root = f2fs_iget(sb, F2FS_ROOT_INO(sbi));
3312 if (IS_ERR(root)) {
Namjae Jeona07ef782012-12-30 14:52:05 +09003313 f2fs_msg(sb, KERN_ERR, "Failed to read root inode");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003314 err = PTR_ERR(root);
Sahitya Tummala60aa4d52018-12-26 11:20:29 +05303315 goto free_node_inode;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003316 }
Chao Yubcbfbd62018-06-29 00:19:25 +08003317 if (!S_ISDIR(root->i_mode) || !root->i_blocks ||
3318 !root->i_size || !root->i_nlink) {
Chao Yu9d847952014-07-25 12:55:09 +08003319 iput(root);
Chao Yu8f99a942013-11-28 15:43:43 +08003320 err = -EINVAL;
Sahitya Tummala60aa4d52018-12-26 11:20:29 +05303321 goto free_node_inode;
Chao Yu8f99a942013-11-28 15:43:43 +08003322 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003323
3324 sb->s_root = d_make_root(root); /* allocate root dentry */
3325 if (!sb->s_root) {
3326 err = -ENOMEM;
Chengguang Xu025cdb162019-01-23 15:49:44 +08003327 goto free_node_inode;
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003328 }
3329
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -07003330 err = f2fs_register_sysfs(sbi);
Namjae Jeonb59d0ba2013-08-04 23:09:40 +09003331 if (err)
Chao Yua3981012017-06-14 17:39:46 +08003332 goto free_root_inode;
Namjae Jeonb59d0ba2013-08-04 23:09:40 +09003333
Jaegeuk Kimea676732017-10-06 09:14:28 -07003334#ifdef CONFIG_QUOTA
Sheng Yong76cf05d2018-07-26 19:24:25 +08003335 /* Enable quota usage during mount */
Chao Yu7beb01f2018-10-24 18:34:26 +08003336 if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sb)) {
Jaegeuk Kimea676732017-10-06 09:14:28 -07003337 err = f2fs_enable_quotas(sb);
Jaegeuk Kim730746c2018-10-02 17:20:58 -07003338 if (err)
Jaegeuk Kimea676732017-10-06 09:14:28 -07003339 f2fs_msg(sb, KERN_ERR,
3340 "Cannot turn on quotas: error %d", err);
Jaegeuk Kimea676732017-10-06 09:14:28 -07003341 }
3342#endif
Chao Yu4b2414d2017-08-08 10:54:31 +08003343 /* if there are nt orphan nodes free them */
Chao Yu4d57b862018-05-30 00:20:41 +08003344 err = f2fs_recover_orphan_inodes(sbi);
Chao Yu4b2414d2017-08-08 10:54:31 +08003345 if (err)
Jaegeuk Kimea676732017-10-06 09:14:28 -07003346 goto free_meta;
Chao Yu4b2414d2017-08-08 10:54:31 +08003347
Daniel Rosenberg43549942018-08-20 19:21:43 -07003348 if (unlikely(is_set_ckpt_flags(sbi, CP_DISABLED_FLAG)))
Chao Yuaa2c8c42019-02-19 16:23:53 +08003349 goto reset_checkpoint;
Daniel Rosenberg43549942018-08-20 19:21:43 -07003350
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003351 /* recover fsynced data */
3352 if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) {
Jaegeuk Kim081d78c2015-01-23 19:16:59 -08003353 /*
3354 * mount should be failed, when device has readonly mode, and
3355 * previous checkpoint was not done by clean system shutdown.
3356 */
3357 if (bdev_read_only(sb->s_bdev) &&
Chao Yuaaec2b12016-09-20 11:04:18 +08003358 !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
Jaegeuk Kim081d78c2015-01-23 19:16:59 -08003359 err = -EROFS;
Chao Yu4b2414d2017-08-08 10:54:31 +08003360 goto free_meta;
Jaegeuk Kim081d78c2015-01-23 19:16:59 -08003361 }
Chao Yu2adc3502015-03-16 21:08:44 +08003362
3363 if (need_fsck)
3364 set_sbi_flag(sbi, SBI_NEED_FSCK);
3365
Chao Yuaa2c8c42019-02-19 16:23:53 +08003366 if (skip_recovery)
3367 goto reset_checkpoint;
Jaegeuk Kima468f0e2016-09-19 17:55:10 -07003368
Chao Yu4d57b862018-05-30 00:20:41 +08003369 err = f2fs_recover_fsync_data(sbi, false);
Jaegeuk Kim6781eab2016-03-23 16:12:58 -07003370 if (err < 0) {
Chao Yuaa2c8c42019-02-19 16:23:53 +08003371 if (err != -ENOMEM)
3372 skip_recovery = true;
Chao Yu2adc3502015-03-16 21:08:44 +08003373 need_fsck = true;
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003374 f2fs_msg(sb, KERN_ERR,
Sheng Yong99e3e852016-05-11 17:08:14 +08003375 "Cannot recover all fsync data errno=%d", err);
Chao Yu4b2414d2017-08-08 10:54:31 +08003376 goto free_meta;
Jaegeuk Kimed2e6212014-08-08 15:37:41 -07003377 }
Jaegeuk Kim6781eab2016-03-23 16:12:58 -07003378 } else {
Chao Yu4d57b862018-05-30 00:20:41 +08003379 err = f2fs_recover_fsync_data(sbi, true);
Jaegeuk Kim6781eab2016-03-23 16:12:58 -07003380
3381 if (!f2fs_readonly(sb) && err > 0) {
3382 err = -EINVAL;
3383 f2fs_msg(sb, KERN_ERR,
3384 "Need to recover fsync data");
Jaegeuk Kimea676732017-10-06 09:14:28 -07003385 goto free_meta;
Jaegeuk Kim6781eab2016-03-23 16:12:58 -07003386 }
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003387 }
Chao Yuaa2c8c42019-02-19 16:23:53 +08003388reset_checkpoint:
Chao Yu4d57b862018-05-30 00:20:41 +08003389 /* f2fs_recover_fsync_data() cleared this already */
Jaegeuk Kim315df832015-08-11 12:45:39 -07003390 clear_sbi_flag(sbi, SBI_POR_DOING);
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003391
Daniel Rosenberg43549942018-08-20 19:21:43 -07003392 if (test_opt(sbi, DISABLE_CHECKPOINT)) {
3393 err = f2fs_disable_checkpoint(sbi);
3394 if (err)
Jaegeuk Kim812a9592019-01-22 14:04:33 -08003395 goto sync_free_meta;
Daniel Rosenberg43549942018-08-20 19:21:43 -07003396 } else if (is_set_ckpt_flags(sbi, CP_DISABLED_FLAG)) {
3397 f2fs_enable_checkpoint(sbi);
3398 }
3399
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003400 /*
3401 * If filesystem is not mounted as read-only then
3402 * do start the gc_thread.
3403 */
Chao Yu6c029932014-11-18 11:16:01 +08003404 if (test_opt(sbi, BG_GC) && !f2fs_readonly(sb)) {
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003405 /* After POR, we can run background GC thread.*/
Chao Yu4d57b862018-05-30 00:20:41 +08003406 err = f2fs_start_gc_thread(sbi);
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003407 if (err)
Jaegeuk Kim812a9592019-01-22 14:04:33 -08003408 goto sync_free_meta;
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003409 }
Jaegeuk Kim52225952018-12-13 18:38:33 -08003410 kvfree(options);
hujianyangda554e42015-05-21 14:42:53 +08003411
3412 /* recover broken superblock */
Jaegeuk Kimf2353d72016-03-23 10:42:01 -07003413 if (recovery) {
Chao Yu41214b32016-02-22 18:33:20 +08003414 err = f2fs_commit_super(sbi, true);
3415 f2fs_msg(sb, KERN_INFO,
Sheng Yong99e3e852016-05-11 17:08:14 +08003416 "Try to recover %dth superblock, ret: %d",
Chao Yu41214b32016-02-22 18:33:20 +08003417 sbi->valid_super_block ? 1 : 2, err);
hujianyangda554e42015-05-21 14:42:53 +08003418 }
3419
Chao Yubae01ed2017-11-30 19:28:20 +08003420 f2fs_join_shrinker(sbi);
3421
Jaegeuk Kim84b89e52018-02-22 14:09:30 -08003422 f2fs_tuning_parameters(sbi);
3423
Jaegeuk Kim1200abb2017-02-09 13:25:35 -08003424 f2fs_msg(sbi->sb, KERN_NOTICE, "Mounted with checkpoint version = %llx",
3425 cur_cp_version(F2FS_CKPT(sbi)));
Jaegeuk Kim6beceb52016-01-08 15:51:50 -08003426 f2fs_update_time(sbi, CP_TIME);
Jaegeuk Kimd0239e12016-01-08 16:57:48 -08003427 f2fs_update_time(sbi, REQ_TIME);
Jaegeuk Kimdb610a62019-01-24 17:48:38 -08003428 clear_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003429 return 0;
Jaegeuk Kim6437d1b2014-02-19 18:23:32 +09003430
Jaegeuk Kim812a9592019-01-22 14:04:33 -08003431sync_free_meta:
3432 /* safe to flush all the data */
3433 sync_filesystem(sbi->sb);
Chao Yuaa2c8c42019-02-19 16:23:53 +08003434 retry_cnt = 0;
Jaegeuk Kim812a9592019-01-22 14:04:33 -08003435
Chao Yu4b2414d2017-08-08 10:54:31 +08003436free_meta:
Jaegeuk Kimea676732017-10-06 09:14:28 -07003437#ifdef CONFIG_QUOTA
Sheng Yong26b5a072018-10-12 18:49:26 +08003438 f2fs_truncate_quota_inode_pages(sb);
Chao Yu7beb01f2018-10-24 18:34:26 +08003439 if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sb))
Jaegeuk Kimea676732017-10-06 09:14:28 -07003440 f2fs_quota_off_umount(sbi->sb);
3441#endif
Chao Yu4b2414d2017-08-08 10:54:31 +08003442 /*
Chao Yu4d57b862018-05-30 00:20:41 +08003443 * Some dirty meta pages can be produced by f2fs_recover_orphan_inodes()
Chao Yu4b2414d2017-08-08 10:54:31 +08003444 * failed by EIO. Then, iput(node_inode) can trigger balance_fs_bg()
Chao Yu4d57b862018-05-30 00:20:41 +08003445 * followed by f2fs_write_checkpoint() through f2fs_write_node_pages(), which
3446 * falls into an infinite loop in f2fs_sync_meta_pages().
Chao Yu4b2414d2017-08-08 10:54:31 +08003447 */
3448 truncate_inode_pages_final(META_MAPPING(sbi));
Jaegeuk Kim812a9592019-01-22 14:04:33 -08003449 /* evict some inodes being cached by GC */
3450 evict_inodes(sb);
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -07003451 f2fs_unregister_sysfs(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003452free_root_inode:
3453 dput(sb->s_root);
3454 sb->s_root = NULL;
Chao Yubae01ed2017-11-30 19:28:20 +08003455free_node_inode:
Chao Yu4d57b862018-05-30 00:20:41 +08003456 f2fs_release_ino_entry(sbi, true);
Chao Yubae01ed2017-11-30 19:28:20 +08003457 truncate_inode_pages_final(NODE_MAPPING(sbi));
3458 iput(sbi->node_inode);
Jaegeuk Kim7c77bf72019-01-01 00:11:30 -08003459 sbi->node_inode = NULL;
Sahitya Tummala60aa4d52018-12-26 11:20:29 +05303460free_stats:
3461 f2fs_destroy_stats(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003462free_nm:
Chao Yu4d57b862018-05-30 00:20:41 +08003463 f2fs_destroy_node_manager(sbi);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003464free_sm:
Chao Yu4d57b862018-05-30 00:20:41 +08003465 f2fs_destroy_segment_manager(sbi);
Jaegeuk Kim3c62be12016-10-06 19:02:05 -07003466free_devices:
3467 destroy_device_list(sbi);
Jaegeuk Kim52225952018-12-13 18:38:33 -08003468 kvfree(sbi->ckpt);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003469free_meta_inode:
3470 make_bad_inode(sbi->meta_inode);
3471 iput(sbi->meta_inode);
Jaegeuk Kim7c77bf72019-01-01 00:11:30 -08003472 sbi->meta_inode = NULL;
Jaegeuk Kim0a595eb2016-12-14 10:12:56 -08003473free_io_dummy:
3474 mempool_destroy(sbi->write_io_dummy);
Chao Yud7997e62018-01-17 16:31:35 +08003475free_percpu:
3476 destroy_percpu_info(sbi);
3477free_bio_info:
Jaegeuk Kima912b542017-05-10 11:18:25 -07003478 for (i = 0; i < NR_PAGE_TYPE; i++)
Jaegeuk Kim52225952018-12-13 18:38:33 -08003479 kvfree(sbi->write_io[i]);
Chao Yud7997e62018-01-17 16:31:35 +08003480free_options:
Chao Yu4b2414d2017-08-08 10:54:31 +08003481#ifdef CONFIG_QUOTA
3482 for (i = 0; i < MAXQUOTAS; i++)
Jaegeuk Kim52225952018-12-13 18:38:33 -08003483 kvfree(F2FS_OPTION(sbi).s_qf_names[i]);
Chao Yu4b2414d2017-08-08 10:54:31 +08003484#endif
Jaegeuk Kim52225952018-12-13 18:38:33 -08003485 kvfree(options);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003486free_sb_buf:
Jaegeuk Kim52225952018-12-13 18:38:33 -08003487 kvfree(raw_super);
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003488free_sbi:
Keith Mok43b65732016-03-02 12:04:24 -08003489 if (sbi->s_chksum_driver)
3490 crypto_free_shash(sbi->s_chksum_driver);
Jaegeuk Kim52225952018-12-13 18:38:33 -08003491 kvfree(sbi);
Jaegeuk Kimed2e6212014-08-08 15:37:41 -07003492
3493 /* give only one another chance */
Chao Yuaa2c8c42019-02-19 16:23:53 +08003494 if (retry_cnt > 0 && skip_recovery) {
3495 retry_cnt--;
Jaegeuk Kimed2e6212014-08-08 15:37:41 -07003496 shrink_dcache_sb(sb);
3497 goto try_onemore;
3498 }
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003499 return err;
3500}
3501
3502static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags,
3503 const char *dev_name, void *data)
3504{
3505 return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super);
3506}
3507
Jaegeuk Kim30a55372015-01-14 16:34:24 -08003508static void kill_f2fs_super(struct super_block *sb)
3509{
Chao Yucce13252017-06-29 23:17:45 +08003510 if (sb->s_root) {
Jaegeuk Kim1cb50f82018-07-06 16:47:34 -07003511 struct f2fs_sb_info *sbi = F2FS_SB(sb);
3512
3513 set_sbi_flag(sbi, SBI_IS_CLOSE);
3514 f2fs_stop_gc_thread(sbi);
3515 f2fs_stop_discard_thread(sbi);
3516
3517 if (is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||
3518 !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
3519 struct cp_control cpc = {
3520 .reason = CP_UMOUNT,
3521 };
3522 f2fs_write_checkpoint(sbi, &cpc);
3523 }
Chao Yu13787522018-08-22 17:11:05 +08003524
3525 if (is_sbi_flag_set(sbi, SBI_IS_RECOVERED) && f2fs_readonly(sb))
3526 sb->s_flags &= ~SB_RDONLY;
Chao Yucce13252017-06-29 23:17:45 +08003527 }
Jaegeuk Kim30a55372015-01-14 16:34:24 -08003528 kill_block_super(sb);
3529}
3530
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003531static struct file_system_type f2fs_fs_type = {
3532 .owner = THIS_MODULE,
3533 .name = "f2fs",
3534 .mount = f2fs_mount,
Jaegeuk Kim30a55372015-01-14 16:34:24 -08003535 .kill_sb = kill_f2fs_super,
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003536 .fs_flags = FS_REQUIRES_DEV,
3537};
Eric W. Biederman7f78e032013-03-02 19:39:14 -08003538MODULE_ALIAS_FS("f2fs");
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003539
Namjae Jeon6e6093a2013-01-17 00:08:30 +09003540static int __init init_inodecache(void)
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003541{
Vladimir Davydov5d097052016-01-14 15:18:21 -08003542 f2fs_inode_cachep = kmem_cache_create("f2fs_inode_cache",
3543 sizeof(struct f2fs_inode_info), 0,
3544 SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT, NULL);
Jaegeuk Kim6bacf522013-12-06 15:00:58 +09003545 if (!f2fs_inode_cachep)
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003546 return -ENOMEM;
3547 return 0;
3548}
3549
3550static void destroy_inodecache(void)
3551{
3552 /*
3553 * Make sure all delayed rcu free inodes are flushed before we
3554 * destroy cache.
3555 */
3556 rcu_barrier();
3557 kmem_cache_destroy(f2fs_inode_cachep);
3558}
3559
3560static int __init init_f2fs_fs(void)
3561{
3562 int err;
3563
Anatoly Pugachev4071e672018-05-28 02:06:37 +03003564 if (PAGE_SIZE != F2FS_BLKSIZE) {
3565 printk("F2FS not supported on PAGE_SIZE(%lu) != %d\n",
3566 PAGE_SIZE, F2FS_BLKSIZE);
3567 return -EINVAL;
3568 }
3569
Jaegeuk Kimc0508652015-01-07 14:07:36 -08003570 f2fs_build_trace_ios();
3571
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003572 err = init_inodecache();
3573 if (err)
3574 goto fail;
Chao Yu4d57b862018-05-30 00:20:41 +08003575 err = f2fs_create_node_manager_caches();
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003576 if (err)
Zhao Hongjiang9890ff32013-08-20 16:49:51 +08003577 goto free_inodecache;
Chao Yu4d57b862018-05-30 00:20:41 +08003578 err = f2fs_create_segment_manager_caches();
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003579 if (err)
Zhao Hongjiang9890ff32013-08-20 16:49:51 +08003580 goto free_node_manager_caches;
Chao Yu4d57b862018-05-30 00:20:41 +08003581 err = f2fs_create_checkpoint_caches();
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003582 if (err)
Chao Yu06292072014-12-29 15:56:18 +08003583 goto free_segment_manager_caches;
Chao Yu4d57b862018-05-30 00:20:41 +08003584 err = f2fs_create_extent_cache();
Chao Yu1dcc3362015-02-05 17:57:31 +08003585 if (err)
3586 goto free_checkpoint_caches;
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -07003587 err = f2fs_init_sysfs();
Chao Yua3981012017-06-14 17:39:46 +08003588 if (err)
Chao Yu1dcc3362015-02-05 17:57:31 +08003589 goto free_extent_cache;
Jaegeuk Kim2658e502015-06-19 12:01:21 -07003590 err = register_shrinker(&f2fs_shrinker_info);
Jaegeuk Kimcfc4d972015-05-15 15:37:24 -07003591 if (err)
Chao Yua3981012017-06-14 17:39:46 +08003592 goto free_sysfs;
Jaegeuk Kim2658e502015-06-19 12:01:21 -07003593 err = register_filesystem(&f2fs_fs_type);
3594 if (err)
3595 goto free_shrinker;
Greg Kroah-Hartmanc20e57b2019-01-04 14:26:18 +01003596 f2fs_create_root_stats();
Eric Biggers6dbb1792018-04-18 11:09:48 -07003597 err = f2fs_init_post_read_processing();
3598 if (err)
3599 goto free_root_stats;
Zhao Hongjiang9890ff32013-08-20 16:49:51 +08003600 return 0;
3601
Eric Biggers6dbb1792018-04-18 11:09:48 -07003602free_root_stats:
3603 f2fs_destroy_root_stats();
Chao Yu787c7b8c2015-10-29 09:13:04 +08003604 unregister_filesystem(&f2fs_fs_type);
Jaegeuk Kim2658e502015-06-19 12:01:21 -07003605free_shrinker:
3606 unregister_shrinker(&f2fs_shrinker_info);
Chao Yua3981012017-06-14 17:39:46 +08003607free_sysfs:
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -07003608 f2fs_exit_sysfs();
Chao Yu1dcc3362015-02-05 17:57:31 +08003609free_extent_cache:
Chao Yu4d57b862018-05-30 00:20:41 +08003610 f2fs_destroy_extent_cache();
Zhao Hongjiang9890ff32013-08-20 16:49:51 +08003611free_checkpoint_caches:
Chao Yu4d57b862018-05-30 00:20:41 +08003612 f2fs_destroy_checkpoint_caches();
Jaegeuk Kim7fd9e542013-11-15 13:55:58 +09003613free_segment_manager_caches:
Chao Yu4d57b862018-05-30 00:20:41 +08003614 f2fs_destroy_segment_manager_caches();
Zhao Hongjiang9890ff32013-08-20 16:49:51 +08003615free_node_manager_caches:
Chao Yu4d57b862018-05-30 00:20:41 +08003616 f2fs_destroy_node_manager_caches();
Zhao Hongjiang9890ff32013-08-20 16:49:51 +08003617free_inodecache:
3618 destroy_inodecache();
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003619fail:
3620 return err;
3621}
3622
3623static void __exit exit_f2fs_fs(void)
3624{
Eric Biggers6dbb1792018-04-18 11:09:48 -07003625 f2fs_destroy_post_read_processing();
Namjae Jeon4589d252013-01-15 19:58:47 +09003626 f2fs_destroy_root_stats();
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003627 unregister_filesystem(&f2fs_fs_type);
Tiezhu Yangb8bef792016-05-18 08:02:25 +08003628 unregister_shrinker(&f2fs_shrinker_info);
Jaegeuk Kimdc6b2052017-07-26 11:24:13 -07003629 f2fs_exit_sysfs();
Chao Yu4d57b862018-05-30 00:20:41 +08003630 f2fs_destroy_extent_cache();
3631 f2fs_destroy_checkpoint_caches();
3632 f2fs_destroy_segment_manager_caches();
3633 f2fs_destroy_node_manager_caches();
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003634 destroy_inodecache();
Jaegeuk Kim351f4fb2015-01-07 14:09:48 -08003635 f2fs_destroy_trace_ios();
Jaegeuk Kimaff063e2012-11-02 17:07:47 +09003636}
3637
3638module_init(init_f2fs_fs)
3639module_exit(exit_f2fs_fs)
3640
3641MODULE_AUTHOR("Samsung Electronics's Praesto Team");
3642MODULE_DESCRIPTION("Flash Friendly File System");
3643MODULE_LICENSE("GPL");
Jaegeuk Kimb4b9d342016-11-04 14:59:15 -07003644