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