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