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