Branch data Line data Source code
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/statfs.h>
12 : : #include <linux/buffer_head.h>
13 : : #include <linux/backing-dev.h>
14 : : #include <linux/kthread.h>
15 : : #include <linux/parser.h>
16 : : #include <linux/mount.h>
17 : : #include <linux/seq_file.h>
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 : :
28 : : #include "f2fs.h"
29 : : #include "node.h"
30 : : #include "segment.h"
31 : : #include "xattr.h"
32 : : #include "gc.h"
33 : : #include "trace.h"
34 : :
35 : : #define CREATE_TRACE_POINTS
36 : : #include <trace/events/f2fs.h>
37 : :
38 : : static struct kmem_cache *f2fs_inode_cachep;
39 : :
40 : : #ifdef CONFIG_F2FS_FAULT_INJECTION
41 : :
42 : : const char *f2fs_fault_name[FAULT_MAX] = {
43 : : [FAULT_KMALLOC] = "kmalloc",
44 : : [FAULT_KVMALLOC] = "kvmalloc",
45 : : [FAULT_PAGE_ALLOC] = "page alloc",
46 : : [FAULT_PAGE_GET] = "page get",
47 : : [FAULT_ALLOC_BIO] = "alloc bio",
48 : : [FAULT_ALLOC_NID] = "alloc nid",
49 : : [FAULT_ORPHAN] = "orphan",
50 : : [FAULT_BLOCK] = "no more block",
51 : : [FAULT_DIR_DEPTH] = "too big dir depth",
52 : : [FAULT_EVICT_INODE] = "evict_inode fail",
53 : : [FAULT_TRUNCATE] = "truncate fail",
54 : : [FAULT_READ_IO] = "read IO error",
55 : : [FAULT_CHECKPOINT] = "checkpoint error",
56 : : [FAULT_DISCARD] = "discard error",
57 : : [FAULT_WRITE_IO] = "write IO error",
58 : : };
59 : :
60 : : void f2fs_build_fault_attr(struct f2fs_sb_info *sbi, unsigned int rate,
61 : : unsigned int type)
62 : : {
63 : : struct f2fs_fault_info *ffi = &F2FS_OPTION(sbi).fault_info;
64 : :
65 : : if (rate) {
66 : : atomic_set(&ffi->inject_ops, 0);
67 : : ffi->inject_rate = rate;
68 : : }
69 : :
70 : : if (type)
71 : : ffi->inject_type = type;
72 : :
73 : : if (!rate && !type)
74 : : memset(ffi, 0, sizeof(struct f2fs_fault_info));
75 : : }
76 : : #endif
77 : :
78 : : /* f2fs-wide shrinker description */
79 : : static struct shrinker f2fs_shrinker_info = {
80 : : .scan_objects = f2fs_shrink_scan,
81 : : .count_objects = f2fs_shrink_count,
82 : : .seeks = DEFAULT_SEEKS,
83 : : };
84 : :
85 : : enum {
86 : : Opt_gc_background,
87 : : Opt_disable_roll_forward,
88 : : Opt_norecovery,
89 : : Opt_discard,
90 : : Opt_nodiscard,
91 : : Opt_noheap,
92 : : Opt_heap,
93 : : Opt_user_xattr,
94 : : Opt_nouser_xattr,
95 : : Opt_acl,
96 : : Opt_noacl,
97 : : Opt_active_logs,
98 : : Opt_disable_ext_identify,
99 : : Opt_inline_xattr,
100 : : Opt_noinline_xattr,
101 : : Opt_inline_xattr_size,
102 : : Opt_inline_data,
103 : : Opt_inline_dentry,
104 : : Opt_noinline_dentry,
105 : : Opt_flush_merge,
106 : : Opt_noflush_merge,
107 : : Opt_nobarrier,
108 : : Opt_fastboot,
109 : : Opt_extent_cache,
110 : : Opt_noextent_cache,
111 : : Opt_noinline_data,
112 : : Opt_data_flush,
113 : : Opt_reserve_root,
114 : : Opt_resgid,
115 : : Opt_resuid,
116 : : Opt_mode,
117 : : Opt_io_size_bits,
118 : : Opt_fault_injection,
119 : : Opt_fault_type,
120 : : Opt_lazytime,
121 : : Opt_nolazytime,
122 : : Opt_quota,
123 : : Opt_noquota,
124 : : Opt_usrquota,
125 : : Opt_grpquota,
126 : : Opt_prjquota,
127 : : Opt_usrjquota,
128 : : Opt_grpjquota,
129 : : Opt_prjjquota,
130 : : Opt_offusrjquota,
131 : : Opt_offgrpjquota,
132 : : Opt_offprjjquota,
133 : : Opt_jqfmt_vfsold,
134 : : Opt_jqfmt_vfsv0,
135 : : Opt_jqfmt_vfsv1,
136 : : Opt_whint,
137 : : Opt_alloc,
138 : : Opt_fsync,
139 : : Opt_test_dummy_encryption,
140 : : Opt_checkpoint_disable,
141 : : Opt_checkpoint_disable_cap,
142 : : Opt_checkpoint_disable_cap_perc,
143 : : Opt_checkpoint_enable,
144 : : Opt_err,
145 : : };
146 : :
147 : : static match_table_t f2fs_tokens = {
148 : : {Opt_gc_background, "background_gc=%s"},
149 : : {Opt_disable_roll_forward, "disable_roll_forward"},
150 : : {Opt_norecovery, "norecovery"},
151 : : {Opt_discard, "discard"},
152 : : {Opt_nodiscard, "nodiscard"},
153 : : {Opt_noheap, "no_heap"},
154 : : {Opt_heap, "heap"},
155 : : {Opt_user_xattr, "user_xattr"},
156 : : {Opt_nouser_xattr, "nouser_xattr"},
157 : : {Opt_acl, "acl"},
158 : : {Opt_noacl, "noacl"},
159 : : {Opt_active_logs, "active_logs=%u"},
160 : : {Opt_disable_ext_identify, "disable_ext_identify"},
161 : : {Opt_inline_xattr, "inline_xattr"},
162 : : {Opt_noinline_xattr, "noinline_xattr"},
163 : : {Opt_inline_xattr_size, "inline_xattr_size=%u"},
164 : : {Opt_inline_data, "inline_data"},
165 : : {Opt_inline_dentry, "inline_dentry"},
166 : : {Opt_noinline_dentry, "noinline_dentry"},
167 : : {Opt_flush_merge, "flush_merge"},
168 : : {Opt_noflush_merge, "noflush_merge"},
169 : : {Opt_nobarrier, "nobarrier"},
170 : : {Opt_fastboot, "fastboot"},
171 : : {Opt_extent_cache, "extent_cache"},
172 : : {Opt_noextent_cache, "noextent_cache"},
173 : : {Opt_noinline_data, "noinline_data"},
174 : : {Opt_data_flush, "data_flush"},
175 : : {Opt_reserve_root, "reserve_root=%u"},
176 : : {Opt_resgid, "resgid=%u"},
177 : : {Opt_resuid, "resuid=%u"},
178 : : {Opt_mode, "mode=%s"},
179 : : {Opt_io_size_bits, "io_bits=%u"},
180 : : {Opt_fault_injection, "fault_injection=%u"},
181 : : {Opt_fault_type, "fault_type=%u"},
182 : : {Opt_lazytime, "lazytime"},
183 : : {Opt_nolazytime, "nolazytime"},
184 : : {Opt_quota, "quota"},
185 : : {Opt_noquota, "noquota"},
186 : : {Opt_usrquota, "usrquota"},
187 : : {Opt_grpquota, "grpquota"},
188 : : {Opt_prjquota, "prjquota"},
189 : : {Opt_usrjquota, "usrjquota=%s"},
190 : : {Opt_grpjquota, "grpjquota=%s"},
191 : : {Opt_prjjquota, "prjjquota=%s"},
192 : : {Opt_offusrjquota, "usrjquota="},
193 : : {Opt_offgrpjquota, "grpjquota="},
194 : : {Opt_offprjjquota, "prjjquota="},
195 : : {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
196 : : {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
197 : : {Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
198 : : {Opt_whint, "whint_mode=%s"},
199 : : {Opt_alloc, "alloc_mode=%s"},
200 : : {Opt_fsync, "fsync_mode=%s"},
201 : : {Opt_test_dummy_encryption, "test_dummy_encryption"},
202 : : {Opt_checkpoint_disable, "checkpoint=disable"},
203 : : {Opt_checkpoint_disable_cap, "checkpoint=disable:%u"},
204 : : {Opt_checkpoint_disable_cap_perc, "checkpoint=disable:%u%%"},
205 : : {Opt_checkpoint_enable, "checkpoint=enable"},
206 : : {Opt_err, NULL},
207 : : };
208 : :
209 : 0 : void f2fs_printk(struct f2fs_sb_info *sbi, const char *fmt, ...)
210 : : {
211 : : struct va_format vaf;
212 : : va_list args;
213 : : int level;
214 : :
215 : 0 : va_start(args, fmt);
216 : :
217 : : level = printk_get_level(fmt);
218 : 0 : vaf.fmt = printk_skip_level(fmt);
219 : 0 : vaf.va = &args;
220 : 0 : printk("%c%cF2FS-fs (%s): %pV\n",
221 : 0 : KERN_SOH_ASCII, level, sbi->sb->s_id, &vaf);
222 : :
223 : 0 : va_end(args);
224 : 0 : }
225 : :
226 : : #ifdef CONFIG_UNICODE
227 : : static const struct f2fs_sb_encodings {
228 : : __u16 magic;
229 : : char *name;
230 : : char *version;
231 : : } f2fs_sb_encoding_map[] = {
232 : : {F2FS_ENC_UTF8_12_1, "utf8", "12.1.0"},
233 : : };
234 : :
235 : : static int f2fs_sb_read_encoding(const struct f2fs_super_block *sb,
236 : : const struct f2fs_sb_encodings **encoding,
237 : : __u16 *flags)
238 : : {
239 : : __u16 magic = le16_to_cpu(sb->s_encoding);
240 : : int i;
241 : :
242 : : for (i = 0; i < ARRAY_SIZE(f2fs_sb_encoding_map); i++)
243 : : if (magic == f2fs_sb_encoding_map[i].magic)
244 : : break;
245 : :
246 : : if (i >= ARRAY_SIZE(f2fs_sb_encoding_map))
247 : : return -EINVAL;
248 : :
249 : : *encoding = &f2fs_sb_encoding_map[i];
250 : : *flags = le16_to_cpu(sb->s_encoding_flags);
251 : :
252 : : return 0;
253 : : }
254 : : #endif
255 : :
256 : 0 : static inline void limit_reserve_root(struct f2fs_sb_info *sbi)
257 : : {
258 : 0 : block_t limit = min((sbi->user_block_count << 1) / 1000,
259 : : sbi->user_block_count - sbi->reserved_blocks);
260 : :
261 : : /* limit is 0.2% */
262 [ # # # # ]: 0 : if (test_opt(sbi, RESERVE_ROOT) &&
263 : 0 : F2FS_OPTION(sbi).root_reserved_blocks > limit) {
264 : 0 : F2FS_OPTION(sbi).root_reserved_blocks = limit;
265 : 0 : f2fs_info(sbi, "Reduce reserved blocks for root = %u",
266 : : F2FS_OPTION(sbi).root_reserved_blocks);
267 : : }
268 [ # # # # ]: 0 : if (!test_opt(sbi, RESERVE_ROOT) &&
269 : 0 : (!uid_eq(F2FS_OPTION(sbi).s_resuid,
270 [ # # ]: 0 : make_kuid(&init_user_ns, F2FS_DEF_RESUID)) ||
271 : 0 : !gid_eq(F2FS_OPTION(sbi).s_resgid,
272 : : make_kgid(&init_user_ns, F2FS_DEF_RESGID))))
273 : 0 : f2fs_info(sbi, "Ignore s_resuid=%u, s_resgid=%u w/o reserve_root",
274 : : from_kuid_munged(&init_user_ns,
275 : : F2FS_OPTION(sbi).s_resuid),
276 : : from_kgid_munged(&init_user_ns,
277 : : F2FS_OPTION(sbi).s_resgid));
278 : 0 : }
279 : :
280 : 0 : static inline void adjust_unusable_cap_perc(struct f2fs_sb_info *sbi)
281 : : {
282 [ # # ]: 0 : if (!F2FS_OPTION(sbi).unusable_cap_perc)
283 : 0 : return;
284 : :
285 [ # # ]: 0 : if (F2FS_OPTION(sbi).unusable_cap_perc == 100)
286 : 0 : F2FS_OPTION(sbi).unusable_cap = sbi->user_block_count;
287 : : else
288 : 0 : F2FS_OPTION(sbi).unusable_cap = (sbi->user_block_count / 100) *
289 : : F2FS_OPTION(sbi).unusable_cap_perc;
290 : :
291 : 0 : f2fs_info(sbi, "Adjust unusable cap for checkpoint=disable = %u / %u%%",
292 : : F2FS_OPTION(sbi).unusable_cap,
293 : : F2FS_OPTION(sbi).unusable_cap_perc);
294 : : }
295 : :
296 : : static void init_once(void *foo)
297 : : {
298 : : struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;
299 : :
300 : 0 : inode_init_once(&fi->vfs_inode);
301 : : }
302 : :
303 : : #ifdef CONFIG_QUOTA
304 : : static const char * const quotatypes[] = INITQFNAMES;
305 : : #define QTYPE2NAME(t) (quotatypes[t])
306 : 0 : static int f2fs_set_qf_name(struct super_block *sb, int qtype,
307 : : substring_t *args)
308 : : {
309 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
310 : : char *qname;
311 : : int ret = -EINVAL;
312 : :
313 [ # # # # ]: 0 : if (sb_any_quota_loaded(sb) && !F2FS_OPTION(sbi).s_qf_names[qtype]) {
314 : 0 : f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");
315 : 0 : return -EINVAL;
316 : : }
317 [ # # ]: 0 : if (f2fs_sb_has_quota_ino(sbi)) {
318 : 0 : f2fs_info(sbi, "QUOTA feature is enabled, so ignore qf_name");
319 : 0 : return 0;
320 : : }
321 : :
322 : 0 : qname = match_strdup(args);
323 [ # # ]: 0 : if (!qname) {
324 : 0 : f2fs_err(sbi, "Not enough memory for storing quotafile name");
325 : 0 : return -ENOMEM;
326 : : }
327 [ # # ]: 0 : if (F2FS_OPTION(sbi).s_qf_names[qtype]) {
328 [ # # ]: 0 : if (strcmp(F2FS_OPTION(sbi).s_qf_names[qtype], qname) == 0)
329 : : ret = 0;
330 : : else
331 : 0 : f2fs_err(sbi, "%s quota file already specified",
332 : : QTYPE2NAME(qtype));
333 : : goto errout;
334 : : }
335 [ # # ]: 0 : if (strchr(qname, '/')) {
336 : 0 : f2fs_err(sbi, "quotafile must be on filesystem root");
337 : 0 : goto errout;
338 : : }
339 : 0 : F2FS_OPTION(sbi).s_qf_names[qtype] = qname;
340 : 0 : set_opt(sbi, QUOTA);
341 : 0 : return 0;
342 : : errout:
343 : 0 : kvfree(qname);
344 : 0 : return ret;
345 : : }
346 : :
347 : 0 : static int f2fs_clear_qf_name(struct super_block *sb, int qtype)
348 : : {
349 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
350 : :
351 [ # # # # ]: 0 : if (sb_any_quota_loaded(sb) && F2FS_OPTION(sbi).s_qf_names[qtype]) {
352 : 0 : f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");
353 : 0 : return -EINVAL;
354 : : }
355 : 0 : kvfree(F2FS_OPTION(sbi).s_qf_names[qtype]);
356 : 0 : F2FS_OPTION(sbi).s_qf_names[qtype] = NULL;
357 : 0 : return 0;
358 : : }
359 : :
360 : 0 : static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
361 : : {
362 : : /*
363 : : * We do the test below only for project quotas. 'usrquota' and
364 : : * 'grpquota' mount options are allowed even without quota feature
365 : : * to support legacy quotas in quota files.
366 : : */
367 [ # # # # ]: 0 : if (test_opt(sbi, PRJQUOTA) && !f2fs_sb_has_project_quota(sbi)) {
368 : 0 : f2fs_err(sbi, "Project quota feature not enabled. Cannot enable project quota enforcement.");
369 : 0 : return -1;
370 : : }
371 [ # # # # ]: 0 : if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||
372 [ # # ]: 0 : F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||
373 : 0 : F2FS_OPTION(sbi).s_qf_names[PRJQUOTA]) {
374 [ # # # # ]: 0 : if (test_opt(sbi, USRQUOTA) &&
375 : : F2FS_OPTION(sbi).s_qf_names[USRQUOTA])
376 : 0 : clear_opt(sbi, USRQUOTA);
377 : :
378 [ # # # # ]: 0 : if (test_opt(sbi, GRPQUOTA) &&
379 : 0 : F2FS_OPTION(sbi).s_qf_names[GRPQUOTA])
380 : 0 : clear_opt(sbi, GRPQUOTA);
381 : :
382 [ # # # # ]: 0 : if (test_opt(sbi, PRJQUOTA) &&
383 : 0 : F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])
384 : 0 : clear_opt(sbi, PRJQUOTA);
385 : :
386 [ # # ]: 0 : if (test_opt(sbi, GRPQUOTA) || test_opt(sbi, USRQUOTA) ||
387 : : test_opt(sbi, PRJQUOTA)) {
388 : 0 : f2fs_err(sbi, "old and new quota format mixing");
389 : 0 : return -1;
390 : : }
391 : :
392 [ # # ]: 0 : if (!F2FS_OPTION(sbi).s_jquota_fmt) {
393 : 0 : f2fs_err(sbi, "journaled quota format not specified");
394 : 0 : return -1;
395 : : }
396 : : }
397 : :
398 [ # # # # ]: 0 : if (f2fs_sb_has_quota_ino(sbi) && F2FS_OPTION(sbi).s_jquota_fmt) {
399 : 0 : f2fs_info(sbi, "QUOTA feature is enabled, so ignore jquota_fmt");
400 : 0 : F2FS_OPTION(sbi).s_jquota_fmt = 0;
401 : : }
402 : : return 0;
403 : : }
404 : : #endif
405 : :
406 : 0 : static int parse_options(struct super_block *sb, char *options)
407 : : {
408 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
409 : : substring_t args[MAX_OPT_ARGS];
410 : : char *p, *name;
411 : 0 : int arg = 0;
412 : : kuid_t uid;
413 : : kgid_t gid;
414 : : #ifdef CONFIG_QUOTA
415 : : int ret;
416 : : #endif
417 : :
418 [ # # ]: 0 : if (!options)
419 : : return 0;
420 : :
421 [ # # ]: 0 : while ((p = strsep(&options, ",")) != NULL) {
422 : : int token;
423 [ # # ]: 0 : if (!*p)
424 : 0 : continue;
425 : : /*
426 : : * Initialize args struct so we know whether arg was
427 : : * found; some options take optional arguments.
428 : : */
429 : 0 : args[0].to = args[0].from = NULL;
430 : 0 : token = match_token(p, f2fs_tokens, args);
431 : :
432 [ # # # # : 0 : switch (token) {
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
433 : : case Opt_gc_background:
434 : 0 : name = match_strdup(&args[0]);
435 : :
436 [ # # ]: 0 : if (!name)
437 : : return -ENOMEM;
438 [ # # # # ]: 0 : if (strlen(name) == 2 && !strncmp(name, "on", 2)) {
439 : 0 : set_opt(sbi, BG_GC);
440 : 0 : clear_opt(sbi, FORCE_FG_GC);
441 [ # # # # ]: 0 : } else if (strlen(name) == 3 && !strncmp(name, "off", 3)) {
442 : 0 : clear_opt(sbi, BG_GC);
443 : 0 : clear_opt(sbi, FORCE_FG_GC);
444 [ # # # # ]: 0 : } else if (strlen(name) == 4 && !strncmp(name, "sync", 4)) {
445 : 0 : set_opt(sbi, BG_GC);
446 : 0 : set_opt(sbi, FORCE_FG_GC);
447 : : } else {
448 : 0 : kvfree(name);
449 : 0 : return -EINVAL;
450 : : }
451 : 0 : kvfree(name);
452 : 0 : break;
453 : : case Opt_disable_roll_forward:
454 : 0 : set_opt(sbi, DISABLE_ROLL_FORWARD);
455 : 0 : break;
456 : : case Opt_norecovery:
457 : : /* this option mounts f2fs with ro */
458 : 0 : set_opt(sbi, NORECOVERY);
459 [ # # ]: 0 : if (!f2fs_readonly(sb))
460 : : return -EINVAL;
461 : : break;
462 : : case Opt_discard:
463 : 0 : set_opt(sbi, DISCARD);
464 : 0 : break;
465 : : case Opt_nodiscard:
466 [ # # ]: 0 : if (f2fs_sb_has_blkzoned(sbi)) {
467 : 0 : f2fs_warn(sbi, "discard is required for zoned block devices");
468 : 0 : return -EINVAL;
469 : : }
470 : 0 : clear_opt(sbi, DISCARD);
471 : 0 : break;
472 : : case Opt_noheap:
473 : 0 : set_opt(sbi, NOHEAP);
474 : 0 : break;
475 : : case Opt_heap:
476 : 0 : clear_opt(sbi, NOHEAP);
477 : 0 : break;
478 : : #ifdef CONFIG_F2FS_FS_XATTR
479 : : case Opt_user_xattr:
480 : 0 : set_opt(sbi, XATTR_USER);
481 : 0 : break;
482 : : case Opt_nouser_xattr:
483 : 0 : clear_opt(sbi, XATTR_USER);
484 : 0 : break;
485 : : case Opt_inline_xattr:
486 : 0 : set_opt(sbi, INLINE_XATTR);
487 : 0 : break;
488 : : case Opt_noinline_xattr:
489 : 0 : clear_opt(sbi, INLINE_XATTR);
490 : 0 : break;
491 : : case Opt_inline_xattr_size:
492 [ # # # # ]: 0 : if (args->from && match_int(args, &arg))
493 : : return -EINVAL;
494 : 0 : set_opt(sbi, INLINE_XATTR_SIZE);
495 : 0 : F2FS_OPTION(sbi).inline_xattr_size = arg;
496 : 0 : break;
497 : : #else
498 : : case Opt_user_xattr:
499 : : f2fs_info(sbi, "user_xattr options not supported");
500 : : break;
501 : : case Opt_nouser_xattr:
502 : : f2fs_info(sbi, "nouser_xattr options not supported");
503 : : break;
504 : : case Opt_inline_xattr:
505 : : f2fs_info(sbi, "inline_xattr options not supported");
506 : : break;
507 : : case Opt_noinline_xattr:
508 : : f2fs_info(sbi, "noinline_xattr options not supported");
509 : : break;
510 : : #endif
511 : : #ifdef CONFIG_F2FS_FS_POSIX_ACL
512 : : case Opt_acl:
513 : 0 : set_opt(sbi, POSIX_ACL);
514 : 0 : break;
515 : : case Opt_noacl:
516 : 0 : clear_opt(sbi, POSIX_ACL);
517 : 0 : break;
518 : : #else
519 : : case Opt_acl:
520 : : f2fs_info(sbi, "acl options not supported");
521 : : break;
522 : : case Opt_noacl:
523 : : f2fs_info(sbi, "noacl options not supported");
524 : : break;
525 : : #endif
526 : : case Opt_active_logs:
527 [ # # # # ]: 0 : if (args->from && match_int(args, &arg))
528 : : return -EINVAL;
529 [ # # # # ]: 0 : if (arg != 2 && arg != 4 && arg != NR_CURSEG_TYPE)
530 : : return -EINVAL;
531 : 0 : F2FS_OPTION(sbi).active_logs = arg;
532 : 0 : break;
533 : : case Opt_disable_ext_identify:
534 : 0 : set_opt(sbi, DISABLE_EXT_IDENTIFY);
535 : 0 : break;
536 : : case Opt_inline_data:
537 : 0 : set_opt(sbi, INLINE_DATA);
538 : 0 : break;
539 : : case Opt_inline_dentry:
540 : 0 : set_opt(sbi, INLINE_DENTRY);
541 : 0 : break;
542 : : case Opt_noinline_dentry:
543 : 0 : clear_opt(sbi, INLINE_DENTRY);
544 : 0 : break;
545 : : case Opt_flush_merge:
546 : 0 : set_opt(sbi, FLUSH_MERGE);
547 : 0 : break;
548 : : case Opt_noflush_merge:
549 : 0 : clear_opt(sbi, FLUSH_MERGE);
550 : 0 : break;
551 : : case Opt_nobarrier:
552 : 0 : set_opt(sbi, NOBARRIER);
553 : 0 : break;
554 : : case Opt_fastboot:
555 : 0 : set_opt(sbi, FASTBOOT);
556 : 0 : break;
557 : : case Opt_extent_cache:
558 : 0 : set_opt(sbi, EXTENT_CACHE);
559 : 0 : break;
560 : : case Opt_noextent_cache:
561 : 0 : clear_opt(sbi, EXTENT_CACHE);
562 : 0 : break;
563 : : case Opt_noinline_data:
564 : 0 : clear_opt(sbi, INLINE_DATA);
565 : 0 : break;
566 : : case Opt_data_flush:
567 : 0 : set_opt(sbi, DATA_FLUSH);
568 : 0 : break;
569 : : case Opt_reserve_root:
570 [ # # # # ]: 0 : if (args->from && match_int(args, &arg))
571 : : return -EINVAL;
572 [ # # ]: 0 : if (test_opt(sbi, RESERVE_ROOT)) {
573 : 0 : f2fs_info(sbi, "Preserve previous reserve_root=%u",
574 : : F2FS_OPTION(sbi).root_reserved_blocks);
575 : : } else {
576 : 0 : F2FS_OPTION(sbi).root_reserved_blocks = arg;
577 : 0 : set_opt(sbi, RESERVE_ROOT);
578 : : }
579 : : break;
580 : : case Opt_resuid:
581 [ # # # # ]: 0 : if (args->from && match_int(args, &arg))
582 : : return -EINVAL;
583 : 0 : uid = make_kuid(current_user_ns(), arg);
584 [ # # ]: 0 : if (!uid_valid(uid)) {
585 : 0 : f2fs_err(sbi, "Invalid uid value %d", arg);
586 : 0 : return -EINVAL;
587 : : }
588 : 0 : F2FS_OPTION(sbi).s_resuid = uid;
589 : 0 : break;
590 : : case Opt_resgid:
591 [ # # # # ]: 0 : if (args->from && match_int(args, &arg))
592 : : return -EINVAL;
593 : 0 : gid = make_kgid(current_user_ns(), arg);
594 [ # # ]: 0 : if (!gid_valid(gid)) {
595 : 0 : f2fs_err(sbi, "Invalid gid value %d", arg);
596 : 0 : return -EINVAL;
597 : : }
598 : 0 : F2FS_OPTION(sbi).s_resgid = gid;
599 : 0 : break;
600 : : case Opt_mode:
601 : 0 : name = match_strdup(&args[0]);
602 : :
603 [ # # ]: 0 : if (!name)
604 : : return -ENOMEM;
605 [ # # # # ]: 0 : if (strlen(name) == 8 &&
606 : 0 : !strncmp(name, "adaptive", 8)) {
607 [ # # ]: 0 : if (f2fs_sb_has_blkzoned(sbi)) {
608 : 0 : f2fs_warn(sbi, "adaptive mode is not allowed with zoned block device feature");
609 : 0 : kvfree(name);
610 : 0 : return -EINVAL;
611 : : }
612 : : set_opt_mode(sbi, F2FS_MOUNT_ADAPTIVE);
613 [ # # # # ]: 0 : } else if (strlen(name) == 3 &&
614 : 0 : !strncmp(name, "lfs", 3)) {
615 : : set_opt_mode(sbi, F2FS_MOUNT_LFS);
616 : : } else {
617 : 0 : kvfree(name);
618 : 0 : return -EINVAL;
619 : : }
620 : 0 : kvfree(name);
621 : 0 : break;
622 : : case Opt_io_size_bits:
623 [ # # # # ]: 0 : if (args->from && match_int(args, &arg))
624 : : return -EINVAL;
625 [ # # # # ]: 0 : if (arg <= 0 || arg > __ilog2_u32(BIO_MAX_PAGES)) {
626 : 0 : f2fs_warn(sbi, "Not support %d, larger than %d",
627 : : 1 << arg, BIO_MAX_PAGES);
628 : 0 : return -EINVAL;
629 : : }
630 : 0 : F2FS_OPTION(sbi).write_io_size_bits = arg;
631 : 0 : break;
632 : : #ifdef CONFIG_F2FS_FAULT_INJECTION
633 : : case Opt_fault_injection:
634 : : if (args->from && match_int(args, &arg))
635 : : return -EINVAL;
636 : : f2fs_build_fault_attr(sbi, arg, F2FS_ALL_FAULT_TYPE);
637 : : set_opt(sbi, FAULT_INJECTION);
638 : : break;
639 : :
640 : : case Opt_fault_type:
641 : : if (args->from && match_int(args, &arg))
642 : : return -EINVAL;
643 : : f2fs_build_fault_attr(sbi, 0, arg);
644 : : set_opt(sbi, FAULT_INJECTION);
645 : : break;
646 : : #else
647 : : case Opt_fault_injection:
648 : 0 : f2fs_info(sbi, "fault_injection options not supported");
649 : 0 : break;
650 : :
651 : : case Opt_fault_type:
652 : 0 : f2fs_info(sbi, "fault_type options not supported");
653 : 0 : break;
654 : : #endif
655 : : case Opt_lazytime:
656 : 0 : sb->s_flags |= SB_LAZYTIME;
657 : 0 : break;
658 : : case Opt_nolazytime:
659 : 0 : sb->s_flags &= ~SB_LAZYTIME;
660 : 0 : break;
661 : : #ifdef CONFIG_QUOTA
662 : : case Opt_quota:
663 : : case Opt_usrquota:
664 : 0 : set_opt(sbi, USRQUOTA);
665 : 0 : break;
666 : : case Opt_grpquota:
667 : 0 : set_opt(sbi, GRPQUOTA);
668 : 0 : break;
669 : : case Opt_prjquota:
670 : 0 : set_opt(sbi, PRJQUOTA);
671 : 0 : break;
672 : : case Opt_usrjquota:
673 : 0 : ret = f2fs_set_qf_name(sb, USRQUOTA, &args[0]);
674 [ # # ]: 0 : if (ret)
675 : 0 : return ret;
676 : : break;
677 : : case Opt_grpjquota:
678 : 0 : ret = f2fs_set_qf_name(sb, GRPQUOTA, &args[0]);
679 [ # # ]: 0 : if (ret)
680 : 0 : return ret;
681 : : break;
682 : : case Opt_prjjquota:
683 : 0 : ret = f2fs_set_qf_name(sb, PRJQUOTA, &args[0]);
684 [ # # ]: 0 : if (ret)
685 : 0 : return ret;
686 : : break;
687 : : case Opt_offusrjquota:
688 : 0 : ret = f2fs_clear_qf_name(sb, USRQUOTA);
689 [ # # ]: 0 : if (ret)
690 : 0 : return ret;
691 : : break;
692 : : case Opt_offgrpjquota:
693 : 0 : ret = f2fs_clear_qf_name(sb, GRPQUOTA);
694 [ # # ]: 0 : if (ret)
695 : 0 : return ret;
696 : : break;
697 : : case Opt_offprjjquota:
698 : 0 : ret = f2fs_clear_qf_name(sb, PRJQUOTA);
699 [ # # ]: 0 : if (ret)
700 : 0 : return ret;
701 : : break;
702 : : case Opt_jqfmt_vfsold:
703 : 0 : F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_OLD;
704 : 0 : break;
705 : : case Opt_jqfmt_vfsv0:
706 : 0 : F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V0;
707 : 0 : break;
708 : : case Opt_jqfmt_vfsv1:
709 : 0 : F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V1;
710 : 0 : break;
711 : : case Opt_noquota:
712 : 0 : clear_opt(sbi, QUOTA);
713 : 0 : clear_opt(sbi, USRQUOTA);
714 : 0 : clear_opt(sbi, GRPQUOTA);
715 : 0 : clear_opt(sbi, PRJQUOTA);
716 : 0 : break;
717 : : #else
718 : : case Opt_quota:
719 : : case Opt_usrquota:
720 : : case Opt_grpquota:
721 : : case Opt_prjquota:
722 : : case Opt_usrjquota:
723 : : case Opt_grpjquota:
724 : : case Opt_prjjquota:
725 : : case Opt_offusrjquota:
726 : : case Opt_offgrpjquota:
727 : : case Opt_offprjjquota:
728 : : case Opt_jqfmt_vfsold:
729 : : case Opt_jqfmt_vfsv0:
730 : : case Opt_jqfmt_vfsv1:
731 : : case Opt_noquota:
732 : : f2fs_info(sbi, "quota operations not supported");
733 : : break;
734 : : #endif
735 : : case Opt_whint:
736 : 0 : name = match_strdup(&args[0]);
737 [ # # ]: 0 : if (!name)
738 : : return -ENOMEM;
739 [ # # # # ]: 0 : if (strlen(name) == 10 &&
740 : 0 : !strncmp(name, "user-based", 10)) {
741 : 0 : F2FS_OPTION(sbi).whint_mode = WHINT_MODE_USER;
742 [ # # # # ]: 0 : } else if (strlen(name) == 3 &&
743 : 0 : !strncmp(name, "off", 3)) {
744 : 0 : F2FS_OPTION(sbi).whint_mode = WHINT_MODE_OFF;
745 [ # # # # ]: 0 : } else if (strlen(name) == 8 &&
746 : 0 : !strncmp(name, "fs-based", 8)) {
747 : 0 : F2FS_OPTION(sbi).whint_mode = WHINT_MODE_FS;
748 : : } else {
749 : 0 : kvfree(name);
750 : 0 : return -EINVAL;
751 : : }
752 : 0 : kvfree(name);
753 : 0 : break;
754 : : case Opt_alloc:
755 : 0 : name = match_strdup(&args[0]);
756 [ # # ]: 0 : if (!name)
757 : : return -ENOMEM;
758 : :
759 [ # # # # ]: 0 : if (strlen(name) == 7 &&
760 : 0 : !strncmp(name, "default", 7)) {
761 : 0 : F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;
762 [ # # # # ]: 0 : } else if (strlen(name) == 5 &&
763 : 0 : !strncmp(name, "reuse", 5)) {
764 : 0 : F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
765 : : } else {
766 : 0 : kvfree(name);
767 : 0 : return -EINVAL;
768 : : }
769 : 0 : kvfree(name);
770 : 0 : break;
771 : : case Opt_fsync:
772 : 0 : name = match_strdup(&args[0]);
773 [ # # ]: 0 : if (!name)
774 : : return -ENOMEM;
775 [ # # # # ]: 0 : if (strlen(name) == 5 &&
776 : 0 : !strncmp(name, "posix", 5)) {
777 : 0 : F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;
778 [ # # # # ]: 0 : } else if (strlen(name) == 6 &&
779 : 0 : !strncmp(name, "strict", 6)) {
780 : 0 : F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_STRICT;
781 [ # # # # ]: 0 : } else if (strlen(name) == 9 &&
782 : 0 : !strncmp(name, "nobarrier", 9)) {
783 : 0 : F2FS_OPTION(sbi).fsync_mode =
784 : : FSYNC_MODE_NOBARRIER;
785 : : } else {
786 : 0 : kvfree(name);
787 : 0 : return -EINVAL;
788 : : }
789 : 0 : kvfree(name);
790 : 0 : break;
791 : : case Opt_test_dummy_encryption:
792 : : #ifdef CONFIG_FS_ENCRYPTION
793 [ # # ]: 0 : if (!f2fs_sb_has_encrypt(sbi)) {
794 : 0 : f2fs_err(sbi, "Encrypt feature is off");
795 : 0 : return -EINVAL;
796 : : }
797 : :
798 : 0 : F2FS_OPTION(sbi).test_dummy_encryption = true;
799 : 0 : f2fs_info(sbi, "Test dummy encryption mode enabled");
800 : : #else
801 : : f2fs_info(sbi, "Test dummy encryption mount option ignored");
802 : : #endif
803 : 0 : break;
804 : : case Opt_checkpoint_disable_cap_perc:
805 [ # # # # ]: 0 : if (args->from && match_int(args, &arg))
806 : : return -EINVAL;
807 [ # # ]: 0 : if (arg < 0 || arg > 100)
808 : : return -EINVAL;
809 : 0 : F2FS_OPTION(sbi).unusable_cap_perc = arg;
810 : 0 : set_opt(sbi, DISABLE_CHECKPOINT);
811 : 0 : break;
812 : : case Opt_checkpoint_disable_cap:
813 [ # # # # ]: 0 : if (args->from && match_int(args, &arg))
814 : : return -EINVAL;
815 : 0 : F2FS_OPTION(sbi).unusable_cap = arg;
816 : 0 : set_opt(sbi, DISABLE_CHECKPOINT);
817 : 0 : break;
818 : : case Opt_checkpoint_disable:
819 : 0 : set_opt(sbi, DISABLE_CHECKPOINT);
820 : 0 : break;
821 : : case Opt_checkpoint_enable:
822 : 0 : clear_opt(sbi, DISABLE_CHECKPOINT);
823 : 0 : break;
824 : : default:
825 : 0 : f2fs_err(sbi, "Unrecognized mount option \"%s\" or missing value",
826 : : p);
827 : 0 : return -EINVAL;
828 : : }
829 : : }
830 : : #ifdef CONFIG_QUOTA
831 [ # # ]: 0 : if (f2fs_check_quota_options(sbi))
832 : : return -EINVAL;
833 : : #else
834 : : if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sbi->sb)) {
835 : : f2fs_info(sbi, "Filesystem with quota feature cannot be mounted RDWR without CONFIG_QUOTA");
836 : : return -EINVAL;
837 : : }
838 : : if (f2fs_sb_has_project_quota(sbi) && !f2fs_readonly(sbi->sb)) {
839 : : f2fs_err(sbi, "Filesystem with project quota feature cannot be mounted RDWR without CONFIG_QUOTA");
840 : : return -EINVAL;
841 : : }
842 : : #endif
843 : : #ifndef CONFIG_UNICODE
844 [ # # ]: 0 : if (f2fs_sb_has_casefold(sbi)) {
845 : 0 : f2fs_err(sbi,
846 : : "Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");
847 : 0 : return -EINVAL;
848 : : }
849 : : #endif
850 : :
851 [ # # # # ]: 0 : if (F2FS_IO_SIZE_BITS(sbi) && !test_opt(sbi, LFS)) {
852 : 0 : f2fs_err(sbi, "Should set mode=lfs with %uKB-sized IO",
853 : : F2FS_IO_SIZE_KB(sbi));
854 : 0 : return -EINVAL;
855 : : }
856 : :
857 [ # # ]: 0 : if (test_opt(sbi, INLINE_XATTR_SIZE)) {
858 : : int min_size, max_size;
859 : :
860 [ # # # # ]: 0 : if (!f2fs_sb_has_extra_attr(sbi) ||
861 : : !f2fs_sb_has_flexible_inline_xattr(sbi)) {
862 : 0 : f2fs_err(sbi, "extra_attr or flexible_inline_xattr feature is off");
863 : 0 : return -EINVAL;
864 : : }
865 [ # # ]: 0 : if (!test_opt(sbi, INLINE_XATTR)) {
866 : 0 : f2fs_err(sbi, "inline_xattr_size option should be set with inline_xattr option");
867 : 0 : return -EINVAL;
868 : : }
869 : :
870 : : min_size = sizeof(struct f2fs_xattr_header) / sizeof(__le32);
871 : : max_size = MAX_INLINE_XATTR_SIZE;
872 : :
873 [ # # # # ]: 0 : if (F2FS_OPTION(sbi).inline_xattr_size < min_size ||
874 : : F2FS_OPTION(sbi).inline_xattr_size > max_size) {
875 : 0 : f2fs_err(sbi, "inline xattr size is out of range: %d ~ %d",
876 : : min_size, max_size);
877 : 0 : return -EINVAL;
878 : : }
879 : : }
880 : :
881 [ # # ]: 0 : if (test_opt(sbi, DISABLE_CHECKPOINT) && test_opt(sbi, LFS)) {
882 : 0 : f2fs_err(sbi, "LFS not compatible with checkpoint=disable\n");
883 : 0 : return -EINVAL;
884 : : }
885 : :
886 : : /* Not pass down write hints if the number of active logs is lesser
887 : : * than NR_CURSEG_TYPE.
888 : : */
889 [ # # ]: 0 : if (F2FS_OPTION(sbi).active_logs != NR_CURSEG_TYPE)
890 : 0 : F2FS_OPTION(sbi).whint_mode = WHINT_MODE_OFF;
891 : : return 0;
892 : : }
893 : :
894 : 0 : static struct inode *f2fs_alloc_inode(struct super_block *sb)
895 : : {
896 : : struct f2fs_inode_info *fi;
897 : :
898 : 0 : fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_F2FS_ZERO);
899 [ # # ]: 0 : if (!fi)
900 : : return NULL;
901 : :
902 : : init_once((void *) fi);
903 : :
904 : : /* Initialize f2fs-specific inode info */
905 : : atomic_set(&fi->dirty_pages, 0);
906 : 0 : init_rwsem(&fi->i_sem);
907 : 0 : INIT_LIST_HEAD(&fi->dirty_list);
908 : 0 : INIT_LIST_HEAD(&fi->gdirty_list);
909 : 0 : INIT_LIST_HEAD(&fi->inmem_ilist);
910 : 0 : INIT_LIST_HEAD(&fi->inmem_pages);
911 : 0 : mutex_init(&fi->inmem_lock);
912 : 0 : init_rwsem(&fi->i_gc_rwsem[READ]);
913 : 0 : init_rwsem(&fi->i_gc_rwsem[WRITE]);
914 : 0 : init_rwsem(&fi->i_mmap_sem);
915 : 0 : init_rwsem(&fi->i_xattr_sem);
916 : :
917 : : /* Will be used by directory only */
918 : 0 : fi->i_dir_level = F2FS_SB(sb)->dir_level;
919 : :
920 : 0 : return &fi->vfs_inode;
921 : : }
922 : :
923 : 0 : static int f2fs_drop_inode(struct inode *inode)
924 : : {
925 : : struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
926 : : int ret;
927 : :
928 : : /*
929 : : * during filesystem shutdown, if checkpoint is disabled,
930 : : * drop useless meta/node dirty pages.
931 : : */
932 [ # # ]: 0 : if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
933 [ # # # # ]: 0 : if (inode->i_ino == F2FS_NODE_INO(sbi) ||
934 : 0 : inode->i_ino == F2FS_META_INO(sbi)) {
935 : 0 : trace_f2fs_drop_inode(inode, 1);
936 : 0 : return 1;
937 : : }
938 : : }
939 : :
940 : : /*
941 : : * This is to avoid a deadlock condition like below.
942 : : * writeback_single_inode(inode)
943 : : * - f2fs_write_data_page
944 : : * - f2fs_gc -> iput -> evict
945 : : * - inode_wait_for_writeback(inode)
946 : : */
947 [ # # # # ]: 0 : if ((!inode_unhashed(inode) && inode->i_state & I_SYNC)) {
948 [ # # # # ]: 0 : if (!inode->i_nlink && !is_bad_inode(inode)) {
949 : : /* to avoid evict_inode call simultaneously */
950 : 0 : atomic_inc(&inode->i_count);
951 : : spin_unlock(&inode->i_lock);
952 : :
953 : : /* some remained atomic pages should discarded */
954 [ # # ]: 0 : if (f2fs_is_atomic_file(inode))
955 : 0 : f2fs_drop_inmem_pages(inode);
956 : :
957 : : /* should remain fi->extent_tree for writepage */
958 : 0 : f2fs_destroy_extent_node(inode);
959 : :
960 : 0 : sb_start_intwrite(inode->i_sb);
961 : 0 : f2fs_i_size_write(inode, 0);
962 : :
963 : 0 : f2fs_submit_merged_write_cond(F2FS_I_SB(inode),
964 : : inode, NULL, 0, DATA);
965 : 0 : truncate_inode_pages_final(inode->i_mapping);
966 : :
967 [ # # ]: 0 : if (F2FS_HAS_BLOCKS(inode))
968 : 0 : f2fs_truncate(inode);
969 : :
970 : 0 : sb_end_intwrite(inode->i_sb);
971 : :
972 : : spin_lock(&inode->i_lock);
973 : : atomic_dec(&inode->i_count);
974 : : }
975 : 0 : trace_f2fs_drop_inode(inode, 0);
976 : 0 : return 0;
977 : : }
978 : : ret = generic_drop_inode(inode);
979 [ # # ]: 0 : if (!ret)
980 : 0 : ret = fscrypt_drop_inode(inode);
981 : 0 : trace_f2fs_drop_inode(inode, ret);
982 : 0 : return ret;
983 : : }
984 : :
985 : 0 : int f2fs_inode_dirtied(struct inode *inode, bool sync)
986 : : {
987 : : struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
988 : : int ret = 0;
989 : :
990 : : spin_lock(&sbi->inode_lock[DIRTY_META]);
991 [ # # ]: 0 : if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
992 : : ret = 1;
993 : : } else {
994 : 0 : set_inode_flag(inode, FI_DIRTY_INODE);
995 : 0 : stat_inc_dirty_inode(sbi, DIRTY_META);
996 : : }
997 [ # # # # ]: 0 : if (sync && list_empty(&F2FS_I(inode)->gdirty_list)) {
998 : 0 : list_add_tail(&F2FS_I(inode)->gdirty_list,
999 : : &sbi->inode_list[DIRTY_META]);
1000 : 0 : inc_page_count(sbi, F2FS_DIRTY_IMETA);
1001 : : }
1002 : : spin_unlock(&sbi->inode_lock[DIRTY_META]);
1003 : 0 : return ret;
1004 : : }
1005 : :
1006 : 0 : void f2fs_inode_synced(struct inode *inode)
1007 : : {
1008 : : struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1009 : :
1010 : : spin_lock(&sbi->inode_lock[DIRTY_META]);
1011 [ # # ]: 0 : if (!is_inode_flag_set(inode, FI_DIRTY_INODE)) {
1012 : : spin_unlock(&sbi->inode_lock[DIRTY_META]);
1013 : 0 : return;
1014 : : }
1015 [ # # ]: 0 : if (!list_empty(&F2FS_I(inode)->gdirty_list)) {
1016 : : list_del_init(&F2FS_I(inode)->gdirty_list);
1017 : : dec_page_count(sbi, F2FS_DIRTY_IMETA);
1018 : : }
1019 : 0 : clear_inode_flag(inode, FI_DIRTY_INODE);
1020 : 0 : clear_inode_flag(inode, FI_AUTO_RECOVER);
1021 : 0 : stat_dec_dirty_inode(F2FS_I_SB(inode), DIRTY_META);
1022 : : spin_unlock(&sbi->inode_lock[DIRTY_META]);
1023 : : }
1024 : :
1025 : : /*
1026 : : * f2fs_dirty_inode() is called from __mark_inode_dirty()
1027 : : *
1028 : : * We should call set_dirty_inode to write the dirty inode through write_inode.
1029 : : */
1030 : 0 : static void f2fs_dirty_inode(struct inode *inode, int flags)
1031 : : {
1032 : : struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1033 : :
1034 [ # # # # ]: 0 : if (inode->i_ino == F2FS_NODE_INO(sbi) ||
1035 : 0 : inode->i_ino == F2FS_META_INO(sbi))
1036 : : return;
1037 : :
1038 [ # # ]: 0 : if (flags == I_DIRTY_TIME)
1039 : : return;
1040 : :
1041 [ # # ]: 0 : if (is_inode_flag_set(inode, FI_AUTO_RECOVER))
1042 : 0 : clear_inode_flag(inode, FI_AUTO_RECOVER);
1043 : :
1044 : 0 : f2fs_inode_dirtied(inode, false);
1045 : : }
1046 : :
1047 : 0 : static void f2fs_free_inode(struct inode *inode)
1048 : : {
1049 : 0 : fscrypt_free_inode(inode);
1050 : 0 : kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode));
1051 : 0 : }
1052 : :
1053 : : static void destroy_percpu_info(struct f2fs_sb_info *sbi)
1054 : : {
1055 : 0 : percpu_counter_destroy(&sbi->alloc_valid_block_count);
1056 : 0 : percpu_counter_destroy(&sbi->total_valid_inode_count);
1057 : : }
1058 : :
1059 : 0 : static void destroy_device_list(struct f2fs_sb_info *sbi)
1060 : : {
1061 : : int i;
1062 : :
1063 [ # # ]: 0 : for (i = 0; i < sbi->s_ndevs; i++) {
1064 : 0 : blkdev_put(FDEV(i).bdev, FMODE_EXCL);
1065 : : #ifdef CONFIG_BLK_DEV_ZONED
1066 : : kvfree(FDEV(i).blkz_seq);
1067 : : #endif
1068 : : }
1069 : 0 : kvfree(sbi->devs);
1070 : 0 : }
1071 : :
1072 : 0 : static void f2fs_put_super(struct super_block *sb)
1073 : : {
1074 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
1075 : : int i;
1076 : : bool dropped;
1077 : :
1078 : 0 : f2fs_quota_off_umount(sb);
1079 : :
1080 : : /* prevent remaining shrinker jobs */
1081 : 0 : mutex_lock(&sbi->umount_mutex);
1082 : :
1083 : : /*
1084 : : * We don't need to do checkpoint when superblock is clean.
1085 : : * But, the previous checkpoint was not done by umount, it needs to do
1086 : : * clean checkpoint again.
1087 : : */
1088 [ # # # # ]: 0 : if ((is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||
1089 : : !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG))) {
1090 : 0 : struct cp_control cpc = {
1091 : : .reason = CP_UMOUNT,
1092 : : };
1093 : 0 : f2fs_write_checkpoint(sbi, &cpc);
1094 : : }
1095 : :
1096 : : /* be sure to wait for any on-going discard commands */
1097 : 0 : dropped = f2fs_issue_discard_timeout(sbi);
1098 : :
1099 [ # # # # : 0 : if ((f2fs_hw_support_discard(sbi) || f2fs_hw_should_discard(sbi)) &&
# # ]
1100 [ # # ]: 0 : !sbi->discard_blks && !dropped) {
1101 : 0 : struct cp_control cpc = {
1102 : : .reason = CP_UMOUNT | CP_TRIMMED,
1103 : : };
1104 : 0 : f2fs_write_checkpoint(sbi, &cpc);
1105 : : }
1106 : :
1107 : : /*
1108 : : * normally superblock is clean, so we need to release this.
1109 : : * In addition, EIO will skip do checkpoint, we need this as well.
1110 : : */
1111 : 0 : f2fs_release_ino_entry(sbi, true);
1112 : :
1113 : 0 : f2fs_leave_shrinker(sbi);
1114 : 0 : mutex_unlock(&sbi->umount_mutex);
1115 : :
1116 : : /* our cp_error case, we can wait for any writeback page */
1117 : 0 : f2fs_flush_merged_writes(sbi);
1118 : :
1119 : 0 : f2fs_wait_on_all_pages(sbi, F2FS_WB_CP_DATA);
1120 : :
1121 [ # # ]: 0 : f2fs_bug_on(sbi, sbi->fsync_node_num);
1122 : :
1123 : 0 : iput(sbi->node_inode);
1124 : 0 : sbi->node_inode = NULL;
1125 : :
1126 : 0 : iput(sbi->meta_inode);
1127 : 0 : sbi->meta_inode = NULL;
1128 : :
1129 : : /*
1130 : : * iput() can update stat information, if f2fs_write_checkpoint()
1131 : : * above failed with error.
1132 : : */
1133 : 0 : f2fs_destroy_stats(sbi);
1134 : :
1135 : : /* destroy f2fs internal modules */
1136 : 0 : f2fs_destroy_node_manager(sbi);
1137 : 0 : f2fs_destroy_segment_manager(sbi);
1138 : :
1139 : 0 : kvfree(sbi->ckpt);
1140 : :
1141 : 0 : f2fs_unregister_sysfs(sbi);
1142 : :
1143 : 0 : sb->s_fs_info = NULL;
1144 [ # # ]: 0 : if (sbi->s_chksum_driver)
1145 : : crypto_free_shash(sbi->s_chksum_driver);
1146 : 0 : kvfree(sbi->raw_super);
1147 : :
1148 : 0 : destroy_device_list(sbi);
1149 : 0 : mempool_destroy(sbi->write_io_dummy);
1150 : : #ifdef CONFIG_QUOTA
1151 [ # # ]: 0 : for (i = 0; i < MAXQUOTAS; i++)
1152 : 0 : kvfree(F2FS_OPTION(sbi).s_qf_names[i]);
1153 : : #endif
1154 : : destroy_percpu_info(sbi);
1155 [ # # ]: 0 : for (i = 0; i < NR_PAGE_TYPE; i++)
1156 : 0 : kvfree(sbi->write_io[i]);
1157 : : #ifdef CONFIG_UNICODE
1158 : : utf8_unload(sbi->s_encoding);
1159 : : #endif
1160 : 0 : kvfree(sbi);
1161 : 0 : }
1162 : :
1163 : 0 : int f2fs_sync_fs(struct super_block *sb, int sync)
1164 : : {
1165 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
1166 : : int err = 0;
1167 : :
1168 [ # # ]: 0 : if (unlikely(f2fs_cp_error(sbi)))
1169 : : return 0;
1170 [ # # ]: 0 : if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
1171 : : return 0;
1172 : :
1173 : 0 : trace_f2fs_sync_fs(sb, sync);
1174 : :
1175 [ # # ]: 0 : if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
1176 : : return -EAGAIN;
1177 : :
1178 [ # # ]: 0 : if (sync) {
1179 : : struct cp_control cpc;
1180 : :
1181 : 0 : cpc.reason = __get_cp_reason(sbi);
1182 : :
1183 : 0 : mutex_lock(&sbi->gc_mutex);
1184 : 0 : err = f2fs_write_checkpoint(sbi, &cpc);
1185 : 0 : mutex_unlock(&sbi->gc_mutex);
1186 : : }
1187 : : f2fs_trace_ios(NULL, 1);
1188 : :
1189 : 0 : return err;
1190 : : }
1191 : :
1192 : 0 : static int f2fs_freeze(struct super_block *sb)
1193 : : {
1194 [ # # ]: 0 : if (f2fs_readonly(sb))
1195 : : return 0;
1196 : :
1197 : : /* IO error happened before */
1198 [ # # ]: 0 : if (unlikely(f2fs_cp_error(F2FS_SB(sb))))
1199 : : return -EIO;
1200 : :
1201 : : /* must be clean, since sync_filesystem() was already called */
1202 [ # # ]: 0 : if (is_sbi_flag_set(F2FS_SB(sb), SBI_IS_DIRTY))
1203 : : return -EINVAL;
1204 : 0 : return 0;
1205 : : }
1206 : :
1207 : 0 : static int f2fs_unfreeze(struct super_block *sb)
1208 : : {
1209 : 0 : return 0;
1210 : : }
1211 : :
1212 : : #ifdef CONFIG_QUOTA
1213 : 0 : static int f2fs_statfs_project(struct super_block *sb,
1214 : : kprojid_t projid, struct kstatfs *buf)
1215 : : {
1216 : : struct kqid qid;
1217 : : struct dquot *dquot;
1218 : : u64 limit;
1219 : : u64 curblock;
1220 : :
1221 : : qid = make_kqid_projid(projid);
1222 : 0 : dquot = dqget(sb, qid);
1223 [ # # ]: 0 : if (IS_ERR(dquot))
1224 : 0 : return PTR_ERR(dquot);
1225 : : spin_lock(&dquot->dq_dqb_lock);
1226 : :
1227 [ # # # # ]: 0 : limit = min_not_zero(dquot->dq_dqb.dqb_bsoftlimit,
1228 : : dquot->dq_dqb.dqb_bhardlimit);
1229 [ # # ]: 0 : if (limit)
1230 : 0 : limit >>= sb->s_blocksize_bits;
1231 : :
1232 [ # # # # ]: 0 : if (limit && buf->f_blocks > limit) {
1233 : 0 : curblock = (dquot->dq_dqb.dqb_curspace +
1234 : 0 : dquot->dq_dqb.dqb_rsvspace) >> sb->s_blocksize_bits;
1235 : 0 : buf->f_blocks = limit;
1236 : 0 : buf->f_bfree = buf->f_bavail =
1237 : : (buf->f_blocks > curblock) ?
1238 [ # # ]: 0 : (buf->f_blocks - curblock) : 0;
1239 : : }
1240 : :
1241 [ # # # # ]: 0 : limit = min_not_zero(dquot->dq_dqb.dqb_isoftlimit,
1242 : : dquot->dq_dqb.dqb_ihardlimit);
1243 : :
1244 [ # # # # ]: 0 : if (limit && buf->f_files > limit) {
1245 : 0 : buf->f_files = limit;
1246 : 0 : buf->f_ffree =
1247 : 0 : (buf->f_files > dquot->dq_dqb.dqb_curinodes) ?
1248 [ # # ]: 0 : (buf->f_files - dquot->dq_dqb.dqb_curinodes) : 0;
1249 : : }
1250 : :
1251 : : spin_unlock(&dquot->dq_dqb_lock);
1252 : 0 : dqput(dquot);
1253 : 0 : return 0;
1254 : : }
1255 : : #endif
1256 : :
1257 : 0 : static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)
1258 : : {
1259 : 0 : struct super_block *sb = dentry->d_sb;
1260 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
1261 : 0 : u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
1262 : : block_t total_count, user_block_count, start_count;
1263 : : u64 avail_node_count;
1264 : :
1265 : 0 : total_count = le64_to_cpu(sbi->raw_super->block_count);
1266 : 0 : user_block_count = sbi->user_block_count;
1267 : 0 : start_count = le32_to_cpu(sbi->raw_super->segment0_blkaddr);
1268 : 0 : buf->f_type = F2FS_SUPER_MAGIC;
1269 : 0 : buf->f_bsize = sbi->blocksize;
1270 : :
1271 : 0 : buf->f_blocks = total_count - start_count;
1272 : 0 : buf->f_bfree = user_block_count - valid_user_blocks(sbi) -
1273 : 0 : sbi->current_reserved_blocks;
1274 : :
1275 : : spin_lock(&sbi->stat_lock);
1276 [ # # ]: 0 : if (unlikely(buf->f_bfree <= sbi->unusable_block_count))
1277 : 0 : buf->f_bfree = 0;
1278 : : else
1279 : 0 : buf->f_bfree -= sbi->unusable_block_count;
1280 : : spin_unlock(&sbi->stat_lock);
1281 : :
1282 [ # # ]: 0 : if (buf->f_bfree > F2FS_OPTION(sbi).root_reserved_blocks)
1283 : 0 : buf->f_bavail = buf->f_bfree -
1284 : : F2FS_OPTION(sbi).root_reserved_blocks;
1285 : : else
1286 : 0 : buf->f_bavail = 0;
1287 : :
1288 : 0 : avail_node_count = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;
1289 : :
1290 [ # # ]: 0 : if (avail_node_count > user_block_count) {
1291 : 0 : buf->f_files = user_block_count;
1292 : 0 : buf->f_ffree = buf->f_bavail;
1293 : : } else {
1294 : 0 : buf->f_files = avail_node_count;
1295 : 0 : buf->f_ffree = min(avail_node_count - valid_node_count(sbi),
1296 : : buf->f_bavail);
1297 : : }
1298 : :
1299 : 0 : buf->f_namelen = F2FS_NAME_LEN;
1300 : 0 : buf->f_fsid.val[0] = (u32)id;
1301 : 0 : buf->f_fsid.val[1] = (u32)(id >> 32);
1302 : :
1303 : : #ifdef CONFIG_QUOTA
1304 [ # # # # ]: 0 : if (is_inode_flag_set(dentry->d_inode, FI_PROJ_INHERIT) &&
1305 : : sb_has_quota_limits_enabled(sb, PRJQUOTA)) {
1306 : 0 : f2fs_statfs_project(sb, F2FS_I(dentry->d_inode)->i_projid, buf);
1307 : : }
1308 : : #endif
1309 : 0 : return 0;
1310 : : }
1311 : :
1312 : 0 : static inline void f2fs_show_quota_options(struct seq_file *seq,
1313 : : struct super_block *sb)
1314 : : {
1315 : : #ifdef CONFIG_QUOTA
1316 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
1317 : :
1318 [ # # ]: 0 : if (F2FS_OPTION(sbi).s_jquota_fmt) {
1319 : : char *fmtname = "";
1320 : :
1321 [ # # ]: 0 : switch (F2FS_OPTION(sbi).s_jquota_fmt) {
1322 : : case QFMT_VFS_OLD:
1323 : : fmtname = "vfsold";
1324 : : break;
1325 : : case QFMT_VFS_V0:
1326 : : fmtname = "vfsv0";
1327 : : break;
1328 : : case QFMT_VFS_V1:
1329 : : fmtname = "vfsv1";
1330 : : break;
1331 : : }
1332 : 0 : seq_printf(seq, ",jqfmt=%s", fmtname);
1333 : : }
1334 : :
1335 [ # # ]: 0 : if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA])
1336 : 0 : seq_show_option(seq, "usrjquota",
1337 : : F2FS_OPTION(sbi).s_qf_names[USRQUOTA]);
1338 : :
1339 [ # # ]: 0 : if (F2FS_OPTION(sbi).s_qf_names[GRPQUOTA])
1340 : 0 : seq_show_option(seq, "grpjquota",
1341 : : F2FS_OPTION(sbi).s_qf_names[GRPQUOTA]);
1342 : :
1343 [ # # ]: 0 : if (F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])
1344 : 0 : seq_show_option(seq, "prjjquota",
1345 : : F2FS_OPTION(sbi).s_qf_names[PRJQUOTA]);
1346 : : #endif
1347 : 0 : }
1348 : :
1349 : 0 : static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
1350 : : {
1351 : 0 : struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb);
1352 : :
1353 [ # # # # ]: 0 : if (!f2fs_readonly(sbi->sb) && test_opt(sbi, BG_GC)) {
1354 [ # # ]: 0 : if (test_opt(sbi, FORCE_FG_GC))
1355 : 0 : seq_printf(seq, ",background_gc=%s", "sync");
1356 : : else
1357 : 0 : seq_printf(seq, ",background_gc=%s", "on");
1358 : : } else {
1359 : 0 : seq_printf(seq, ",background_gc=%s", "off");
1360 : : }
1361 [ # # ]: 0 : if (test_opt(sbi, DISABLE_ROLL_FORWARD))
1362 : 0 : seq_puts(seq, ",disable_roll_forward");
1363 [ # # ]: 0 : if (test_opt(sbi, NORECOVERY))
1364 : 0 : seq_puts(seq, ",norecovery");
1365 [ # # ]: 0 : if (test_opt(sbi, DISCARD))
1366 : 0 : seq_puts(seq, ",discard");
1367 : : else
1368 : 0 : seq_puts(seq, ",nodiscard");
1369 [ # # ]: 0 : if (test_opt(sbi, NOHEAP))
1370 : 0 : seq_puts(seq, ",no_heap");
1371 : : else
1372 : 0 : seq_puts(seq, ",heap");
1373 : : #ifdef CONFIG_F2FS_FS_XATTR
1374 [ # # ]: 0 : if (test_opt(sbi, XATTR_USER))
1375 : 0 : seq_puts(seq, ",user_xattr");
1376 : : else
1377 : 0 : seq_puts(seq, ",nouser_xattr");
1378 [ # # ]: 0 : if (test_opt(sbi, INLINE_XATTR))
1379 : 0 : seq_puts(seq, ",inline_xattr");
1380 : : else
1381 : 0 : seq_puts(seq, ",noinline_xattr");
1382 [ # # ]: 0 : if (test_opt(sbi, INLINE_XATTR_SIZE))
1383 : 0 : seq_printf(seq, ",inline_xattr_size=%u",
1384 : : F2FS_OPTION(sbi).inline_xattr_size);
1385 : : #endif
1386 : : #ifdef CONFIG_F2FS_FS_POSIX_ACL
1387 [ # # ]: 0 : if (test_opt(sbi, POSIX_ACL))
1388 : 0 : seq_puts(seq, ",acl");
1389 : : else
1390 : 0 : seq_puts(seq, ",noacl");
1391 : : #endif
1392 [ # # ]: 0 : if (test_opt(sbi, DISABLE_EXT_IDENTIFY))
1393 : 0 : seq_puts(seq, ",disable_ext_identify");
1394 [ # # ]: 0 : if (test_opt(sbi, INLINE_DATA))
1395 : 0 : seq_puts(seq, ",inline_data");
1396 : : else
1397 : 0 : seq_puts(seq, ",noinline_data");
1398 [ # # ]: 0 : if (test_opt(sbi, INLINE_DENTRY))
1399 : 0 : seq_puts(seq, ",inline_dentry");
1400 : : else
1401 : 0 : seq_puts(seq, ",noinline_dentry");
1402 [ # # # # ]: 0 : if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE))
1403 : 0 : seq_puts(seq, ",flush_merge");
1404 [ # # ]: 0 : if (test_opt(sbi, NOBARRIER))
1405 : 0 : seq_puts(seq, ",nobarrier");
1406 [ # # ]: 0 : if (test_opt(sbi, FASTBOOT))
1407 : 0 : seq_puts(seq, ",fastboot");
1408 [ # # ]: 0 : if (test_opt(sbi, EXTENT_CACHE))
1409 : 0 : seq_puts(seq, ",extent_cache");
1410 : : else
1411 : 0 : seq_puts(seq, ",noextent_cache");
1412 [ # # ]: 0 : if (test_opt(sbi, DATA_FLUSH))
1413 : 0 : seq_puts(seq, ",data_flush");
1414 : :
1415 : 0 : seq_puts(seq, ",mode=");
1416 [ # # ]: 0 : if (test_opt(sbi, ADAPTIVE))
1417 : 0 : seq_puts(seq, "adaptive");
1418 [ # # ]: 0 : else if (test_opt(sbi, LFS))
1419 : 0 : seq_puts(seq, "lfs");
1420 : 0 : seq_printf(seq, ",active_logs=%u", F2FS_OPTION(sbi).active_logs);
1421 [ # # ]: 0 : if (test_opt(sbi, RESERVE_ROOT))
1422 : 0 : seq_printf(seq, ",reserve_root=%u,resuid=%u,resgid=%u",
1423 : : F2FS_OPTION(sbi).root_reserved_blocks,
1424 : : from_kuid_munged(&init_user_ns,
1425 : : F2FS_OPTION(sbi).s_resuid),
1426 : : from_kgid_munged(&init_user_ns,
1427 : : F2FS_OPTION(sbi).s_resgid));
1428 [ # # ]: 0 : if (F2FS_IO_SIZE_BITS(sbi))
1429 : 0 : seq_printf(seq, ",io_bits=%u",
1430 : : F2FS_OPTION(sbi).write_io_size_bits);
1431 : : #ifdef CONFIG_F2FS_FAULT_INJECTION
1432 : : if (test_opt(sbi, FAULT_INJECTION)) {
1433 : : seq_printf(seq, ",fault_injection=%u",
1434 : : F2FS_OPTION(sbi).fault_info.inject_rate);
1435 : : seq_printf(seq, ",fault_type=%u",
1436 : : F2FS_OPTION(sbi).fault_info.inject_type);
1437 : : }
1438 : : #endif
1439 : : #ifdef CONFIG_QUOTA
1440 [ # # ]: 0 : if (test_opt(sbi, QUOTA))
1441 : 0 : seq_puts(seq, ",quota");
1442 [ # # ]: 0 : if (test_opt(sbi, USRQUOTA))
1443 : 0 : seq_puts(seq, ",usrquota");
1444 [ # # ]: 0 : if (test_opt(sbi, GRPQUOTA))
1445 : 0 : seq_puts(seq, ",grpquota");
1446 [ # # ]: 0 : if (test_opt(sbi, PRJQUOTA))
1447 : 0 : seq_puts(seq, ",prjquota");
1448 : : #endif
1449 : 0 : f2fs_show_quota_options(seq, sbi->sb);
1450 [ # # ]: 0 : if (F2FS_OPTION(sbi).whint_mode == WHINT_MODE_USER)
1451 : 0 : seq_printf(seq, ",whint_mode=%s", "user-based");
1452 [ # # ]: 0 : else if (F2FS_OPTION(sbi).whint_mode == WHINT_MODE_FS)
1453 : 0 : seq_printf(seq, ",whint_mode=%s", "fs-based");
1454 : : #ifdef CONFIG_FS_ENCRYPTION
1455 [ # # ]: 0 : if (F2FS_OPTION(sbi).test_dummy_encryption)
1456 : 0 : seq_puts(seq, ",test_dummy_encryption");
1457 : : #endif
1458 : :
1459 [ # # ]: 0 : if (F2FS_OPTION(sbi).alloc_mode == ALLOC_MODE_DEFAULT)
1460 : 0 : seq_printf(seq, ",alloc_mode=%s", "default");
1461 [ # # ]: 0 : else if (F2FS_OPTION(sbi).alloc_mode == ALLOC_MODE_REUSE)
1462 : 0 : seq_printf(seq, ",alloc_mode=%s", "reuse");
1463 : :
1464 [ # # ]: 0 : if (test_opt(sbi, DISABLE_CHECKPOINT))
1465 : 0 : seq_printf(seq, ",checkpoint=disable:%u",
1466 : : F2FS_OPTION(sbi).unusable_cap);
1467 [ # # ]: 0 : if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_POSIX)
1468 : 0 : seq_printf(seq, ",fsync_mode=%s", "posix");
1469 [ # # ]: 0 : else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT)
1470 : 0 : seq_printf(seq, ",fsync_mode=%s", "strict");
1471 [ # # ]: 0 : else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_NOBARRIER)
1472 : 0 : seq_printf(seq, ",fsync_mode=%s", "nobarrier");
1473 : 0 : return 0;
1474 : : }
1475 : :
1476 : 0 : static void default_options(struct f2fs_sb_info *sbi)
1477 : : {
1478 : : /* init some FS parameters */
1479 : 0 : F2FS_OPTION(sbi).active_logs = NR_CURSEG_TYPE;
1480 : 0 : F2FS_OPTION(sbi).inline_xattr_size = DEFAULT_INLINE_XATTR_ADDRS;
1481 : 0 : F2FS_OPTION(sbi).whint_mode = WHINT_MODE_OFF;
1482 : 0 : F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;
1483 : 0 : F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;
1484 : 0 : F2FS_OPTION(sbi).test_dummy_encryption = false;
1485 : 0 : F2FS_OPTION(sbi).s_resuid = make_kuid(&init_user_ns, F2FS_DEF_RESUID);
1486 : 0 : F2FS_OPTION(sbi).s_resgid = make_kgid(&init_user_ns, F2FS_DEF_RESGID);
1487 : :
1488 : 0 : set_opt(sbi, BG_GC);
1489 : 0 : set_opt(sbi, INLINE_XATTR);
1490 : 0 : set_opt(sbi, INLINE_DATA);
1491 : 0 : set_opt(sbi, INLINE_DENTRY);
1492 : 0 : set_opt(sbi, EXTENT_CACHE);
1493 : 0 : set_opt(sbi, NOHEAP);
1494 : 0 : clear_opt(sbi, DISABLE_CHECKPOINT);
1495 : 0 : F2FS_OPTION(sbi).unusable_cap = 0;
1496 : 0 : sbi->sb->s_flags |= SB_LAZYTIME;
1497 : 0 : set_opt(sbi, FLUSH_MERGE);
1498 : 0 : set_opt(sbi, DISCARD);
1499 [ # # ]: 0 : if (f2fs_sb_has_blkzoned(sbi))
1500 : : set_opt_mode(sbi, F2FS_MOUNT_LFS);
1501 : : else
1502 : : set_opt_mode(sbi, F2FS_MOUNT_ADAPTIVE);
1503 : :
1504 : : #ifdef CONFIG_F2FS_FS_XATTR
1505 : 0 : set_opt(sbi, XATTR_USER);
1506 : : #endif
1507 : : #ifdef CONFIG_F2FS_FS_POSIX_ACL
1508 : 0 : set_opt(sbi, POSIX_ACL);
1509 : : #endif
1510 : :
1511 : : f2fs_build_fault_attr(sbi, 0, 0);
1512 : 0 : }
1513 : :
1514 : : #ifdef CONFIG_QUOTA
1515 : : static int f2fs_enable_quotas(struct super_block *sb);
1516 : : #endif
1517 : :
1518 : 0 : static int f2fs_disable_checkpoint(struct f2fs_sb_info *sbi)
1519 : : {
1520 : 0 : unsigned int s_flags = sbi->sb->s_flags;
1521 : : struct cp_control cpc;
1522 : : int err = 0;
1523 : : int ret;
1524 : : block_t unusable;
1525 : :
1526 [ # # ]: 0 : if (s_flags & SB_RDONLY) {
1527 : 0 : f2fs_err(sbi, "checkpoint=disable on readonly fs");
1528 : 0 : return -EINVAL;
1529 : : }
1530 : 0 : sbi->sb->s_flags |= SB_ACTIVE;
1531 : :
1532 : : f2fs_update_time(sbi, DISABLE_TIME);
1533 : :
1534 [ # # ]: 0 : while (!f2fs_time_over(sbi, DISABLE_TIME)) {
1535 : 0 : mutex_lock(&sbi->gc_mutex);
1536 : 0 : err = f2fs_gc(sbi, true, false, NULL_SEGNO);
1537 [ # # ]: 0 : if (err == -ENODATA) {
1538 : : err = 0;
1539 : : break;
1540 : : }
1541 [ # # ]: 0 : if (err && err != -EAGAIN)
1542 : : break;
1543 : : }
1544 : :
1545 : 0 : ret = sync_filesystem(sbi->sb);
1546 [ # # ]: 0 : if (ret || err) {
1547 [ # # ]: 0 : err = ret ? ret: err;
1548 : 0 : goto restore_flag;
1549 : : }
1550 : :
1551 : 0 : unusable = f2fs_get_unusable_blocks(sbi);
1552 [ # # ]: 0 : if (f2fs_disable_cp_again(sbi, unusable)) {
1553 : : err = -EAGAIN;
1554 : : goto restore_flag;
1555 : : }
1556 : :
1557 : 0 : mutex_lock(&sbi->gc_mutex);
1558 : 0 : cpc.reason = CP_PAUSE;
1559 : : set_sbi_flag(sbi, SBI_CP_DISABLED);
1560 : 0 : err = f2fs_write_checkpoint(sbi, &cpc);
1561 [ # # ]: 0 : if (err)
1562 : : goto out_unlock;
1563 : :
1564 : : spin_lock(&sbi->stat_lock);
1565 : 0 : sbi->unusable_block_count = unusable;
1566 : : spin_unlock(&sbi->stat_lock);
1567 : :
1568 : : out_unlock:
1569 : 0 : mutex_unlock(&sbi->gc_mutex);
1570 : : restore_flag:
1571 : 0 : sbi->sb->s_flags = s_flags; /* Restore MS_RDONLY status */
1572 : 0 : return err;
1573 : : }
1574 : :
1575 : 0 : static void f2fs_enable_checkpoint(struct f2fs_sb_info *sbi)
1576 : : {
1577 : 0 : mutex_lock(&sbi->gc_mutex);
1578 : 0 : f2fs_dirty_to_prefree(sbi);
1579 : :
1580 : : clear_sbi_flag(sbi, SBI_CP_DISABLED);
1581 : : set_sbi_flag(sbi, SBI_IS_DIRTY);
1582 : 0 : mutex_unlock(&sbi->gc_mutex);
1583 : :
1584 : 0 : f2fs_sync_fs(sbi->sb, 1);
1585 : 0 : }
1586 : :
1587 : 0 : static int f2fs_remount(struct super_block *sb, int *flags, char *data)
1588 : : {
1589 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
1590 : : struct f2fs_mount_info org_mount_opt;
1591 : : unsigned long old_sb_flags;
1592 : : int err;
1593 : : bool need_restart_gc = false;
1594 : : bool need_stop_gc = false;
1595 : 0 : bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE);
1596 : 0 : bool disable_checkpoint = test_opt(sbi, DISABLE_CHECKPOINT);
1597 : 0 : bool no_io_align = !F2FS_IO_ALIGNED(sbi);
1598 : : bool checkpoint_changed;
1599 : : #ifdef CONFIG_QUOTA
1600 : : int i, j;
1601 : : #endif
1602 : :
1603 : : /*
1604 : : * Save the old mount options in case we
1605 : : * need to restore them.
1606 : : */
1607 : 0 : org_mount_opt = sbi->mount_opt;
1608 : 0 : old_sb_flags = sb->s_flags;
1609 : :
1610 : : #ifdef CONFIG_QUOTA
1611 : 0 : org_mount_opt.s_jquota_fmt = F2FS_OPTION(sbi).s_jquota_fmt;
1612 [ # # ]: 0 : for (i = 0; i < MAXQUOTAS; i++) {
1613 [ # # ]: 0 : if (F2FS_OPTION(sbi).s_qf_names[i]) {
1614 : 0 : org_mount_opt.s_qf_names[i] =
1615 : 0 : kstrdup(F2FS_OPTION(sbi).s_qf_names[i],
1616 : : GFP_KERNEL);
1617 [ # # ]: 0 : if (!org_mount_opt.s_qf_names[i]) {
1618 [ # # ]: 0 : for (j = 0; j < i; j++)
1619 : 0 : kvfree(org_mount_opt.s_qf_names[j]);
1620 : : return -ENOMEM;
1621 : : }
1622 : : } else {
1623 : 0 : org_mount_opt.s_qf_names[i] = NULL;
1624 : : }
1625 : : }
1626 : : #endif
1627 : :
1628 : : /* recover superblocks we couldn't write due to previous RO mount */
1629 [ # # # # ]: 0 : if (!(*flags & SB_RDONLY) && is_sbi_flag_set(sbi, SBI_NEED_SB_WRITE)) {
1630 : 0 : err = f2fs_commit_super(sbi, false);
1631 : 0 : f2fs_info(sbi, "Try to recover all the superblocks, ret: %d",
1632 : : err);
1633 [ # # ]: 0 : if (!err)
1634 : : clear_sbi_flag(sbi, SBI_NEED_SB_WRITE);
1635 : : }
1636 : :
1637 : 0 : default_options(sbi);
1638 : :
1639 : : /* parse mount options */
1640 : 0 : err = parse_options(sb, data);
1641 [ # # ]: 0 : if (err)
1642 : : goto restore_opts;
1643 : : checkpoint_changed =
1644 : 0 : disable_checkpoint != test_opt(sbi, DISABLE_CHECKPOINT);
1645 : :
1646 : : /*
1647 : : * Previous and new state of filesystem is RO,
1648 : : * so skip checking GC and FLUSH_MERGE conditions.
1649 : : */
1650 [ # # # # ]: 0 : if (f2fs_readonly(sb) && (*flags & SB_RDONLY))
1651 : : goto skip;
1652 : :
1653 : : #ifdef CONFIG_QUOTA
1654 [ # # # # ]: 0 : if (!f2fs_readonly(sb) && (*flags & SB_RDONLY)) {
1655 : : err = dquot_suspend(sb, -1);
1656 [ # # ]: 0 : if (err < 0)
1657 : : goto restore_opts;
1658 [ # # # # ]: 0 : } else if (f2fs_readonly(sb) && !(*flags & SB_RDONLY)) {
1659 : : /* dquot_resume needs RW */
1660 : 0 : sb->s_flags &= ~SB_RDONLY;
1661 [ # # ]: 0 : if (sb_any_quota_suspended(sb)) {
1662 : 0 : dquot_resume(sb, -1);
1663 [ # # ]: 0 : } else if (f2fs_sb_has_quota_ino(sbi)) {
1664 : 0 : err = f2fs_enable_quotas(sb);
1665 [ # # ]: 0 : if (err)
1666 : : goto restore_opts;
1667 : : }
1668 : : }
1669 : : #endif
1670 : : /* disallow enable/disable extent_cache dynamically */
1671 [ # # ]: 0 : if (no_extent_cache == !!test_opt(sbi, EXTENT_CACHE)) {
1672 : : err = -EINVAL;
1673 : 0 : f2fs_warn(sbi, "switch extent_cache option is not allowed");
1674 : 0 : goto restore_opts;
1675 : : }
1676 : :
1677 [ # # ]: 0 : if (no_io_align == !!F2FS_IO_ALIGNED(sbi)) {
1678 : : err = -EINVAL;
1679 : 0 : f2fs_warn(sbi, "switch io_bits option is not allowed");
1680 : 0 : goto restore_opts;
1681 : : }
1682 : :
1683 [ # # # # ]: 0 : if ((*flags & SB_RDONLY) && test_opt(sbi, DISABLE_CHECKPOINT)) {
1684 : : err = -EINVAL;
1685 : 0 : f2fs_warn(sbi, "disabling checkpoint not compatible with read-only");
1686 : 0 : goto restore_opts;
1687 : : }
1688 : :
1689 : : /*
1690 : : * We stop the GC thread if FS is mounted as RO
1691 : : * or if background_gc = off is passed in mount
1692 : : * option. Also sync the filesystem.
1693 : : */
1694 [ # # # # ]: 0 : if ((*flags & SB_RDONLY) || !test_opt(sbi, BG_GC)) {
1695 [ # # ]: 0 : if (sbi->gc_thread) {
1696 : 0 : f2fs_stop_gc_thread(sbi);
1697 : : need_restart_gc = true;
1698 : : }
1699 [ # # ]: 0 : } else if (!sbi->gc_thread) {
1700 : 0 : err = f2fs_start_gc_thread(sbi);
1701 [ # # ]: 0 : if (err)
1702 : : goto restore_opts;
1703 : : need_stop_gc = true;
1704 : : }
1705 : :
1706 [ # # # # ]: 0 : if (*flags & SB_RDONLY ||
1707 : 0 : F2FS_OPTION(sbi).whint_mode != org_mount_opt.whint_mode) {
1708 : 0 : writeback_inodes_sb(sb, WB_REASON_SYNC);
1709 : 0 : sync_inodes_sb(sb);
1710 : :
1711 : : set_sbi_flag(sbi, SBI_IS_DIRTY);
1712 : : set_sbi_flag(sbi, SBI_IS_CLOSE);
1713 : 0 : f2fs_sync_fs(sb, 1);
1714 : : clear_sbi_flag(sbi, SBI_IS_CLOSE);
1715 : : }
1716 : :
1717 [ # # ]: 0 : if (checkpoint_changed) {
1718 [ # # ]: 0 : if (test_opt(sbi, DISABLE_CHECKPOINT)) {
1719 : 0 : err = f2fs_disable_checkpoint(sbi);
1720 [ # # ]: 0 : if (err)
1721 : : goto restore_gc;
1722 : : } else {
1723 : 0 : f2fs_enable_checkpoint(sbi);
1724 : : }
1725 : : }
1726 : :
1727 : : /*
1728 : : * We stop issue flush thread if FS is mounted as RO
1729 : : * or if flush_merge is not passed in mount option.
1730 : : */
1731 [ # # # # ]: 0 : if ((*flags & SB_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {
1732 : 0 : clear_opt(sbi, FLUSH_MERGE);
1733 : 0 : f2fs_destroy_flush_cmd_control(sbi, false);
1734 : : } else {
1735 : 0 : err = f2fs_create_flush_cmd_control(sbi);
1736 [ # # ]: 0 : if (err)
1737 : : goto restore_gc;
1738 : : }
1739 : : skip:
1740 : : #ifdef CONFIG_QUOTA
1741 : : /* Release old quota file names */
1742 [ # # ]: 0 : for (i = 0; i < MAXQUOTAS; i++)
1743 : 0 : kvfree(org_mount_opt.s_qf_names[i]);
1744 : : #endif
1745 : : /* Update the POSIXACL Flag */
1746 [ # # ]: 0 : sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
1747 : 0 : (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
1748 : :
1749 : 0 : limit_reserve_root(sbi);
1750 : 0 : adjust_unusable_cap_perc(sbi);
1751 : 0 : *flags = (*flags & ~SB_LAZYTIME) | (sb->s_flags & SB_LAZYTIME);
1752 : 0 : return 0;
1753 : : restore_gc:
1754 [ # # ]: 0 : if (need_restart_gc) {
1755 [ # # ]: 0 : if (f2fs_start_gc_thread(sbi))
1756 : 0 : f2fs_warn(sbi, "background gc thread has stopped");
1757 [ # # ]: 0 : } else if (need_stop_gc) {
1758 : 0 : f2fs_stop_gc_thread(sbi);
1759 : : }
1760 : : restore_opts:
1761 : : #ifdef CONFIG_QUOTA
1762 : 0 : F2FS_OPTION(sbi).s_jquota_fmt = org_mount_opt.s_jquota_fmt;
1763 [ # # ]: 0 : for (i = 0; i < MAXQUOTAS; i++) {
1764 : 0 : kvfree(F2FS_OPTION(sbi).s_qf_names[i]);
1765 : 0 : F2FS_OPTION(sbi).s_qf_names[i] = org_mount_opt.s_qf_names[i];
1766 : : }
1767 : : #endif
1768 : 0 : sbi->mount_opt = org_mount_opt;
1769 : 0 : sb->s_flags = old_sb_flags;
1770 : 0 : return err;
1771 : : }
1772 : :
1773 : : #ifdef CONFIG_QUOTA
1774 : : /* Read data from quotafile */
1775 : 0 : static ssize_t f2fs_quota_read(struct super_block *sb, int type, char *data,
1776 : : size_t len, loff_t off)
1777 : : {
1778 : 0 : struct inode *inode = sb_dqopt(sb)->files[type];
1779 : 0 : struct address_space *mapping = inode->i_mapping;
1780 : 0 : block_t blkidx = F2FS_BYTES_TO_BLK(off);
1781 : 0 : int offset = off & (sb->s_blocksize - 1);
1782 : : int tocopy;
1783 : : size_t toread;
1784 : : loff_t i_size = i_size_read(inode);
1785 : : struct page *page;
1786 : : char *kaddr;
1787 : :
1788 [ # # ]: 0 : if (off > i_size)
1789 : : return 0;
1790 : :
1791 [ # # ]: 0 : if (off + len > i_size)
1792 : 0 : len = i_size - off;
1793 : : toread = len;
1794 [ # # ]: 0 : while (toread > 0) {
1795 : 0 : tocopy = min_t(unsigned long, sb->s_blocksize - offset, toread);
1796 : : repeat:
1797 : 0 : page = read_cache_page_gfp(mapping, blkidx, GFP_NOFS);
1798 [ # # ]: 0 : if (IS_ERR(page)) {
1799 [ # # ]: 0 : if (PTR_ERR(page) == -ENOMEM) {
1800 : 0 : congestion_wait(BLK_RW_ASYNC, HZ/50);
1801 : 0 : goto repeat;
1802 : : }
1803 : : set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
1804 : 0 : return PTR_ERR(page);
1805 : : }
1806 : :
1807 : 0 : lock_page(page);
1808 : :
1809 [ # # ]: 0 : if (unlikely(page->mapping != mapping)) {
1810 : 0 : f2fs_put_page(page, 1);
1811 : 0 : goto repeat;
1812 : : }
1813 [ # # ]: 0 : if (unlikely(!PageUptodate(page))) {
1814 : 0 : f2fs_put_page(page, 1);
1815 : : set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
1816 : 0 : return -EIO;
1817 : : }
1818 : :
1819 : 0 : kaddr = kmap_atomic(page);
1820 : 0 : memcpy(data, kaddr + offset, tocopy);
1821 : : kunmap_atomic(kaddr);
1822 : 0 : f2fs_put_page(page, 1);
1823 : :
1824 : : offset = 0;
1825 : 0 : toread -= tocopy;
1826 : 0 : data += tocopy;
1827 : 0 : blkidx++;
1828 : : }
1829 : 0 : return len;
1830 : : }
1831 : :
1832 : : /* Write to quotafile */
1833 : 0 : static ssize_t f2fs_quota_write(struct super_block *sb, int type,
1834 : : const char *data, size_t len, loff_t off)
1835 : : {
1836 : 0 : struct inode *inode = sb_dqopt(sb)->files[type];
1837 : 0 : struct address_space *mapping = inode->i_mapping;
1838 : 0 : const struct address_space_operations *a_ops = mapping->a_ops;
1839 : 0 : int offset = off & (sb->s_blocksize - 1);
1840 : : size_t towrite = len;
1841 : : struct page *page;
1842 : 0 : void *fsdata = NULL;
1843 : : char *kaddr;
1844 : : int err = 0;
1845 : : int tocopy;
1846 : :
1847 [ # # ]: 0 : while (towrite > 0) {
1848 : 0 : tocopy = min_t(unsigned long, sb->s_blocksize - offset,
1849 : : towrite);
1850 : : retry:
1851 : 0 : err = a_ops->write_begin(NULL, mapping, off, tocopy, 0,
1852 : : &page, &fsdata);
1853 [ # # ]: 0 : if (unlikely(err)) {
1854 [ # # ]: 0 : if (err == -ENOMEM) {
1855 : 0 : congestion_wait(BLK_RW_ASYNC, HZ/50);
1856 : 0 : goto retry;
1857 : : }
1858 : : set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
1859 : : break;
1860 : : }
1861 : :
1862 : 0 : kaddr = kmap_atomic(page);
1863 : 0 : memcpy(kaddr + offset, data, tocopy);
1864 : : kunmap_atomic(kaddr);
1865 : 0 : flush_dcache_page(page);
1866 : :
1867 : 0 : a_ops->write_end(NULL, mapping, off, tocopy, tocopy,
1868 : : page, fsdata);
1869 : : offset = 0;
1870 : 0 : towrite -= tocopy;
1871 : 0 : off += tocopy;
1872 : 0 : data += tocopy;
1873 : 0 : cond_resched();
1874 : : }
1875 : :
1876 [ # # ]: 0 : if (len == towrite)
1877 : : return err;
1878 : 0 : inode->i_mtime = inode->i_ctime = current_time(inode);
1879 : 0 : f2fs_mark_inode_dirty_sync(inode, false);
1880 : 0 : return len - towrite;
1881 : : }
1882 : :
1883 : 0 : static struct dquot **f2fs_get_dquots(struct inode *inode)
1884 : : {
1885 : 0 : return F2FS_I(inode)->i_dquot;
1886 : : }
1887 : :
1888 : 0 : static qsize_t *f2fs_get_reserved_space(struct inode *inode)
1889 : : {
1890 : 0 : return &F2FS_I(inode)->i_reserved_quota;
1891 : : }
1892 : :
1893 : 0 : static int f2fs_quota_on_mount(struct f2fs_sb_info *sbi, int type)
1894 : : {
1895 [ # # ]: 0 : if (is_set_ckpt_flags(sbi, CP_QUOTA_NEED_FSCK_FLAG)) {
1896 : 0 : f2fs_err(sbi, "quota sysfile may be corrupted, skip loading it");
1897 : 0 : return 0;
1898 : : }
1899 : :
1900 : 0 : return dquot_quota_on_mount(sbi->sb, F2FS_OPTION(sbi).s_qf_names[type],
1901 : : F2FS_OPTION(sbi).s_jquota_fmt, type);
1902 : : }
1903 : :
1904 : 0 : int f2fs_enable_quota_files(struct f2fs_sb_info *sbi, bool rdonly)
1905 : : {
1906 : : int enabled = 0;
1907 : : int i, err;
1908 : :
1909 [ # # # # ]: 0 : if (f2fs_sb_has_quota_ino(sbi) && rdonly) {
1910 : 0 : err = f2fs_enable_quotas(sbi->sb);
1911 [ # # ]: 0 : if (err) {
1912 : 0 : f2fs_err(sbi, "Cannot turn on quota_ino: %d", err);
1913 : 0 : return 0;
1914 : : }
1915 : : return 1;
1916 : : }
1917 : :
1918 [ # # ]: 0 : for (i = 0; i < MAXQUOTAS; i++) {
1919 [ # # ]: 0 : if (F2FS_OPTION(sbi).s_qf_names[i]) {
1920 : 0 : err = f2fs_quota_on_mount(sbi, i);
1921 [ # # ]: 0 : if (!err) {
1922 : : enabled = 1;
1923 : 0 : continue;
1924 : : }
1925 : 0 : f2fs_err(sbi, "Cannot turn on quotas: %d on %d",
1926 : : err, i);
1927 : : }
1928 : : }
1929 : 0 : return enabled;
1930 : : }
1931 : :
1932 : 0 : static int f2fs_quota_enable(struct super_block *sb, int type, int format_id,
1933 : : unsigned int flags)
1934 : : {
1935 : : struct inode *qf_inode;
1936 : : unsigned long qf_inum;
1937 : : int err;
1938 : :
1939 [ # # ]: 0 : BUG_ON(!f2fs_sb_has_quota_ino(F2FS_SB(sb)));
1940 : :
1941 : : qf_inum = f2fs_qf_ino(sb, type);
1942 [ # # ]: 0 : if (!qf_inum)
1943 : : return -EPERM;
1944 : :
1945 : 0 : qf_inode = f2fs_iget(sb, qf_inum);
1946 [ # # ]: 0 : if (IS_ERR(qf_inode)) {
1947 : 0 : f2fs_err(F2FS_SB(sb), "Bad quota inode %u:%lu", type, qf_inum);
1948 : 0 : return PTR_ERR(qf_inode);
1949 : : }
1950 : :
1951 : : /* Don't account quota for quota files to avoid recursion */
1952 : 0 : qf_inode->i_flags |= S_NOQUOTA;
1953 : 0 : err = dquot_enable(qf_inode, type, format_id, flags);
1954 : 0 : iput(qf_inode);
1955 : 0 : return err;
1956 : : }
1957 : :
1958 : 0 : static int f2fs_enable_quotas(struct super_block *sb)
1959 : : {
1960 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
1961 : : int type, err = 0;
1962 : : unsigned long qf_inum;
1963 : 0 : bool quota_mopt[MAXQUOTAS] = {
1964 : 0 : test_opt(sbi, USRQUOTA),
1965 : 0 : test_opt(sbi, GRPQUOTA),
1966 : 0 : test_opt(sbi, PRJQUOTA),
1967 : : };
1968 : :
1969 [ # # ]: 0 : if (is_set_ckpt_flags(F2FS_SB(sb), CP_QUOTA_NEED_FSCK_FLAG)) {
1970 : 0 : f2fs_err(sbi, "quota file may be corrupted, skip loading it");
1971 : 0 : return 0;
1972 : : }
1973 : :
1974 : 0 : sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE;
1975 : :
1976 [ # # ]: 0 : for (type = 0; type < MAXQUOTAS; type++) {
1977 : : qf_inum = f2fs_qf_ino(sb, type);
1978 [ # # ]: 0 : if (qf_inum) {
1979 [ # # ]: 0 : err = f2fs_quota_enable(sb, type, QFMT_VFS_V1,
1980 : : DQUOT_USAGE_ENABLED |
1981 : 0 : (quota_mopt[type] ? DQUOT_LIMITS_ENABLED : 0));
1982 [ # # ]: 0 : if (err) {
1983 : 0 : f2fs_err(sbi, "Failed to enable quota tracking (type=%d, err=%d). Please run fsck to fix.",
1984 : : type, err);
1985 [ # # ]: 0 : for (type--; type >= 0; type--)
1986 : 0 : dquot_quota_off(sb, type);
1987 : : set_sbi_flag(F2FS_SB(sb),
1988 : : SBI_QUOTA_NEED_REPAIR);
1989 : 0 : return err;
1990 : : }
1991 : : }
1992 : : }
1993 : : return 0;
1994 : : }
1995 : :
1996 : 0 : int f2fs_quota_sync(struct super_block *sb, int type)
1997 : : {
1998 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
1999 : : struct quota_info *dqopt = sb_dqopt(sb);
2000 : : int cnt;
2001 : : int ret;
2002 : :
2003 : : /*
2004 : : * do_quotactl
2005 : : * f2fs_quota_sync
2006 : : * down_read(quota_sem)
2007 : : * dquot_writeback_dquots()
2008 : : * f2fs_dquot_commit
2009 : : * block_operation
2010 : : * down_read(quota_sem)
2011 : : */
2012 : : f2fs_lock_op(sbi);
2013 : :
2014 : 0 : down_read(&sbi->quota_sem);
2015 : 0 : ret = dquot_writeback_dquots(sb, type);
2016 [ # # ]: 0 : if (ret)
2017 : : goto out;
2018 : :
2019 : : /*
2020 : : * Now when everything is written we can discard the pagecache so
2021 : : * that userspace sees the changes.
2022 : : */
2023 [ # # ]: 0 : for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2024 : : struct address_space *mapping;
2025 : :
2026 [ # # ]: 0 : if (type != -1 && cnt != type)
2027 : 0 : continue;
2028 [ # # ]: 0 : if (!sb_has_quota_active(sb, cnt))
2029 : 0 : continue;
2030 : :
2031 : 0 : mapping = dqopt->files[cnt]->i_mapping;
2032 : :
2033 : 0 : ret = filemap_fdatawrite(mapping);
2034 [ # # ]: 0 : if (ret)
2035 : : goto out;
2036 : :
2037 : : /* if we are using journalled quota */
2038 [ # # ]: 0 : if (is_journalled_quota(sbi))
2039 : 0 : continue;
2040 : :
2041 : : ret = filemap_fdatawait(mapping);
2042 [ # # ]: 0 : if (ret)
2043 : : set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
2044 : :
2045 : 0 : inode_lock(dqopt->files[cnt]);
2046 : 0 : truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
2047 : 0 : inode_unlock(dqopt->files[cnt]);
2048 : : }
2049 : : out:
2050 [ # # ]: 0 : if (ret)
2051 : : set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
2052 : 0 : up_read(&sbi->quota_sem);
2053 : : f2fs_unlock_op(sbi);
2054 : 0 : return ret;
2055 : : }
2056 : :
2057 : 0 : static int f2fs_quota_on(struct super_block *sb, int type, int format_id,
2058 : : const struct path *path)
2059 : : {
2060 : : struct inode *inode;
2061 : : int err;
2062 : :
2063 : : /* if quota sysfile exists, deny enabling quota with specific file */
2064 [ # # ]: 0 : if (f2fs_sb_has_quota_ino(F2FS_SB(sb))) {
2065 : 0 : f2fs_err(F2FS_SB(sb), "quota sysfile already exists");
2066 : 0 : return -EBUSY;
2067 : : }
2068 : :
2069 : 0 : err = f2fs_quota_sync(sb, type);
2070 [ # # ]: 0 : if (err)
2071 : : return err;
2072 : :
2073 : 0 : err = dquot_quota_on(sb, type, format_id, path);
2074 [ # # ]: 0 : if (err)
2075 : : return err;
2076 : :
2077 : 0 : inode = d_inode(path->dentry);
2078 : :
2079 : : inode_lock(inode);
2080 : 0 : F2FS_I(inode)->i_flags |= F2FS_NOATIME_FL | F2FS_IMMUTABLE_FL;
2081 : 0 : f2fs_set_inode_flags(inode);
2082 : : inode_unlock(inode);
2083 : 0 : f2fs_mark_inode_dirty_sync(inode, false);
2084 : :
2085 : 0 : return 0;
2086 : : }
2087 : :
2088 : 0 : static int __f2fs_quota_off(struct super_block *sb, int type)
2089 : : {
2090 : 0 : struct inode *inode = sb_dqopt(sb)->files[type];
2091 : : int err;
2092 : :
2093 [ # # # # ]: 0 : if (!inode || !igrab(inode))
2094 : 0 : return dquot_quota_off(sb, type);
2095 : :
2096 : 0 : err = f2fs_quota_sync(sb, type);
2097 [ # # ]: 0 : if (err)
2098 : : goto out_put;
2099 : :
2100 : 0 : err = dquot_quota_off(sb, type);
2101 [ # # # # ]: 0 : if (err || f2fs_sb_has_quota_ino(F2FS_SB(sb)))
2102 : : goto out_put;
2103 : :
2104 : : inode_lock(inode);
2105 : 0 : F2FS_I(inode)->i_flags &= ~(F2FS_NOATIME_FL | F2FS_IMMUTABLE_FL);
2106 : 0 : f2fs_set_inode_flags(inode);
2107 : : inode_unlock(inode);
2108 : 0 : f2fs_mark_inode_dirty_sync(inode, false);
2109 : : out_put:
2110 : 0 : iput(inode);
2111 : 0 : return err;
2112 : : }
2113 : :
2114 : 0 : static int f2fs_quota_off(struct super_block *sb, int type)
2115 : : {
2116 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
2117 : : int err;
2118 : :
2119 : 0 : err = __f2fs_quota_off(sb, type);
2120 : :
2121 : : /*
2122 : : * quotactl can shutdown journalled quota, result in inconsistence
2123 : : * between quota record and fs data by following updates, tag the
2124 : : * flag to let fsck be aware of it.
2125 : : */
2126 [ # # ]: 0 : if (is_journalled_quota(sbi))
2127 : : set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
2128 : 0 : return err;
2129 : : }
2130 : :
2131 : 0 : void f2fs_quota_off_umount(struct super_block *sb)
2132 : : {
2133 : : int type;
2134 : : int err;
2135 : :
2136 [ # # ]: 0 : for (type = 0; type < MAXQUOTAS; type++) {
2137 : 0 : err = __f2fs_quota_off(sb, type);
2138 [ # # ]: 0 : if (err) {
2139 : 0 : int ret = dquot_quota_off(sb, type);
2140 : :
2141 : 0 : f2fs_err(F2FS_SB(sb), "Fail to turn off disk quota (type: %d, err: %d, ret:%d), Please run fsck to fix it.",
2142 : : type, err, ret);
2143 : : set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);
2144 : : }
2145 : : }
2146 : : /*
2147 : : * In case of checkpoint=disable, we must flush quota blocks.
2148 : : * This can cause NULL exception for node_inode in end_io, since
2149 : : * put_super already dropped it.
2150 : : */
2151 : 0 : sync_filesystem(sb);
2152 : 0 : }
2153 : :
2154 : 0 : static void f2fs_truncate_quota_inode_pages(struct super_block *sb)
2155 : : {
2156 : : struct quota_info *dqopt = sb_dqopt(sb);
2157 : : int type;
2158 : :
2159 [ # # ]: 0 : for (type = 0; type < MAXQUOTAS; type++) {
2160 [ # # ]: 0 : if (!dqopt->files[type])
2161 : 0 : continue;
2162 : 0 : f2fs_inode_synced(dqopt->files[type]);
2163 : : }
2164 : 0 : }
2165 : :
2166 : 0 : static int f2fs_dquot_commit(struct dquot *dquot)
2167 : : {
2168 : 0 : struct f2fs_sb_info *sbi = F2FS_SB(dquot->dq_sb);
2169 : : int ret;
2170 : :
2171 : 0 : down_read(&sbi->quota_sem);
2172 : 0 : ret = dquot_commit(dquot);
2173 [ # # ]: 0 : if (ret < 0)
2174 : : set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
2175 : 0 : up_read(&sbi->quota_sem);
2176 : 0 : return ret;
2177 : : }
2178 : :
2179 : 0 : static int f2fs_dquot_acquire(struct dquot *dquot)
2180 : : {
2181 : 0 : struct f2fs_sb_info *sbi = F2FS_SB(dquot->dq_sb);
2182 : : int ret;
2183 : :
2184 : 0 : down_read(&sbi->quota_sem);
2185 : 0 : ret = dquot_acquire(dquot);
2186 [ # # ]: 0 : if (ret < 0)
2187 : : set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
2188 : 0 : up_read(&sbi->quota_sem);
2189 : 0 : return ret;
2190 : : }
2191 : :
2192 : 0 : static int f2fs_dquot_release(struct dquot *dquot)
2193 : : {
2194 : 0 : struct f2fs_sb_info *sbi = F2FS_SB(dquot->dq_sb);
2195 : : int ret;
2196 : :
2197 : 0 : down_read(&sbi->quota_sem);
2198 : 0 : ret = dquot_release(dquot);
2199 [ # # ]: 0 : if (ret < 0)
2200 : : set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
2201 : 0 : up_read(&sbi->quota_sem);
2202 : 0 : return ret;
2203 : : }
2204 : :
2205 : 0 : static int f2fs_dquot_mark_dquot_dirty(struct dquot *dquot)
2206 : : {
2207 : 0 : struct super_block *sb = dquot->dq_sb;
2208 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
2209 : : int ret;
2210 : :
2211 : 0 : down_read(&sbi->quota_sem);
2212 : 0 : ret = dquot_mark_dquot_dirty(dquot);
2213 : :
2214 : : /* if we are using journalled quota */
2215 [ # # ]: 0 : if (is_journalled_quota(sbi))
2216 : : set_sbi_flag(sbi, SBI_QUOTA_NEED_FLUSH);
2217 : :
2218 : 0 : up_read(&sbi->quota_sem);
2219 : 0 : return ret;
2220 : : }
2221 : :
2222 : 0 : static int f2fs_dquot_commit_info(struct super_block *sb, int type)
2223 : : {
2224 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
2225 : : int ret;
2226 : :
2227 : 0 : down_read(&sbi->quota_sem);
2228 : 0 : ret = dquot_commit_info(sb, type);
2229 [ # # ]: 0 : if (ret < 0)
2230 : : set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
2231 : 0 : up_read(&sbi->quota_sem);
2232 : 0 : return ret;
2233 : : }
2234 : :
2235 : 0 : static int f2fs_get_projid(struct inode *inode, kprojid_t *projid)
2236 : : {
2237 : 0 : *projid = F2FS_I(inode)->i_projid;
2238 : 0 : return 0;
2239 : : }
2240 : :
2241 : : static const struct dquot_operations f2fs_quota_operations = {
2242 : : .get_reserved_space = f2fs_get_reserved_space,
2243 : : .write_dquot = f2fs_dquot_commit,
2244 : : .acquire_dquot = f2fs_dquot_acquire,
2245 : : .release_dquot = f2fs_dquot_release,
2246 : : .mark_dirty = f2fs_dquot_mark_dquot_dirty,
2247 : : .write_info = f2fs_dquot_commit_info,
2248 : : .alloc_dquot = dquot_alloc,
2249 : : .destroy_dquot = dquot_destroy,
2250 : : .get_projid = f2fs_get_projid,
2251 : : .get_next_id = dquot_get_next_id,
2252 : : };
2253 : :
2254 : : static const struct quotactl_ops f2fs_quotactl_ops = {
2255 : : .quota_on = f2fs_quota_on,
2256 : : .quota_off = f2fs_quota_off,
2257 : : .quota_sync = f2fs_quota_sync,
2258 : : .get_state = dquot_get_state,
2259 : : .set_info = dquot_set_dqinfo,
2260 : : .get_dqblk = dquot_get_dqblk,
2261 : : .set_dqblk = dquot_set_dqblk,
2262 : : .get_nextdqblk = dquot_get_next_dqblk,
2263 : : };
2264 : : #else
2265 : : int f2fs_quota_sync(struct super_block *sb, int type)
2266 : : {
2267 : : return 0;
2268 : : }
2269 : :
2270 : : void f2fs_quota_off_umount(struct super_block *sb)
2271 : : {
2272 : : }
2273 : : #endif
2274 : :
2275 : : static const struct super_operations f2fs_sops = {
2276 : : .alloc_inode = f2fs_alloc_inode,
2277 : : .free_inode = f2fs_free_inode,
2278 : : .drop_inode = f2fs_drop_inode,
2279 : : .write_inode = f2fs_write_inode,
2280 : : .dirty_inode = f2fs_dirty_inode,
2281 : : .show_options = f2fs_show_options,
2282 : : #ifdef CONFIG_QUOTA
2283 : : .quota_read = f2fs_quota_read,
2284 : : .quota_write = f2fs_quota_write,
2285 : : .get_dquots = f2fs_get_dquots,
2286 : : #endif
2287 : : .evict_inode = f2fs_evict_inode,
2288 : : .put_super = f2fs_put_super,
2289 : : .sync_fs = f2fs_sync_fs,
2290 : : .freeze_fs = f2fs_freeze,
2291 : : .unfreeze_fs = f2fs_unfreeze,
2292 : : .statfs = f2fs_statfs,
2293 : : .remount_fs = f2fs_remount,
2294 : : };
2295 : :
2296 : : #ifdef CONFIG_FS_ENCRYPTION
2297 : 0 : static int f2fs_get_context(struct inode *inode, void *ctx, size_t len)
2298 : : {
2299 : 0 : return f2fs_getxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,
2300 : : F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,
2301 : : ctx, len, NULL);
2302 : : }
2303 : :
2304 : 0 : static int f2fs_set_context(struct inode *inode, const void *ctx, size_t len,
2305 : : void *fs_data)
2306 : : {
2307 : : struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2308 : :
2309 : : /*
2310 : : * Encrypting the root directory is not allowed because fsck
2311 : : * expects lost+found directory to exist and remain unencrypted
2312 : : * if LOST_FOUND feature is enabled.
2313 : : *
2314 : : */
2315 [ # # # # ]: 0 : if (f2fs_sb_has_lost_found(sbi) &&
2316 : 0 : inode->i_ino == F2FS_ROOT_INO(sbi))
2317 : : return -EPERM;
2318 : :
2319 : 0 : return f2fs_setxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,
2320 : : F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,
2321 : : ctx, len, fs_data, XATTR_CREATE);
2322 : : }
2323 : :
2324 : 0 : static bool f2fs_dummy_context(struct inode *inode)
2325 : : {
2326 : 0 : return DUMMY_ENCRYPTION_ENABLED(F2FS_I_SB(inode));
2327 : : }
2328 : :
2329 : : static const struct fscrypt_operations f2fs_cryptops = {
2330 : : .key_prefix = "f2fs:",
2331 : : .get_context = f2fs_get_context,
2332 : : .set_context = f2fs_set_context,
2333 : : .dummy_context = f2fs_dummy_context,
2334 : : .empty_dir = f2fs_empty_dir,
2335 : : .max_namelen = F2FS_NAME_LEN,
2336 : : };
2337 : : #endif
2338 : :
2339 : 0 : static struct inode *f2fs_nfs_get_inode(struct super_block *sb,
2340 : : u64 ino, u32 generation)
2341 : : {
2342 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
2343 : : struct inode *inode;
2344 : :
2345 [ # # ]: 0 : if (f2fs_check_nid_range(sbi, ino))
2346 : : return ERR_PTR(-ESTALE);
2347 : :
2348 : : /*
2349 : : * f2fs_iget isn't quite right if the inode is currently unallocated!
2350 : : * However f2fs_iget currently does appropriate checks to handle stale
2351 : : * inodes so everything is OK.
2352 : : */
2353 : 0 : inode = f2fs_iget(sb, ino);
2354 [ # # ]: 0 : if (IS_ERR(inode))
2355 : : return ERR_CAST(inode);
2356 [ # # # # ]: 0 : if (unlikely(generation && inode->i_generation != generation)) {
2357 : : /* we didn't find the right inode.. */
2358 : 0 : iput(inode);
2359 : 0 : return ERR_PTR(-ESTALE);
2360 : : }
2361 : : return inode;
2362 : : }
2363 : :
2364 : 0 : static struct dentry *f2fs_fh_to_dentry(struct super_block *sb, struct fid *fid,
2365 : : int fh_len, int fh_type)
2366 : : {
2367 : 0 : return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
2368 : : f2fs_nfs_get_inode);
2369 : : }
2370 : :
2371 : 0 : static struct dentry *f2fs_fh_to_parent(struct super_block *sb, struct fid *fid,
2372 : : int fh_len, int fh_type)
2373 : : {
2374 : 0 : return generic_fh_to_parent(sb, fid, fh_len, fh_type,
2375 : : f2fs_nfs_get_inode);
2376 : : }
2377 : :
2378 : : static const struct export_operations f2fs_export_ops = {
2379 : : .fh_to_dentry = f2fs_fh_to_dentry,
2380 : : .fh_to_parent = f2fs_fh_to_parent,
2381 : : .get_parent = f2fs_get_parent,
2382 : : };
2383 : :
2384 : : static loff_t max_file_blocks(void)
2385 : : {
2386 : : loff_t result = 0;
2387 : : loff_t leaf_count = DEF_ADDRS_PER_BLOCK;
2388 : :
2389 : : /*
2390 : : * note: previously, result is equal to (DEF_ADDRS_PER_INODE -
2391 : : * DEFAULT_INLINE_XATTR_ADDRS), but now f2fs try to reserve more
2392 : : * space in inode.i_addr, it will be more safe to reassign
2393 : : * result as zero.
2394 : : */
2395 : :
2396 : : /* two direct node blocks */
2397 : : result += (leaf_count * 2);
2398 : :
2399 : : /* two indirect node blocks */
2400 : : leaf_count *= NIDS_PER_BLOCK;
2401 : : result += (leaf_count * 2);
2402 : :
2403 : : /* one double indirect node block */
2404 : : leaf_count *= NIDS_PER_BLOCK;
2405 : : result += leaf_count;
2406 : :
2407 : : return result;
2408 : : }
2409 : :
2410 : 0 : static int __f2fs_commit_super(struct buffer_head *bh,
2411 : : struct f2fs_super_block *super)
2412 : : {
2413 : 0 : lock_buffer(bh);
2414 [ # # ]: 0 : if (super)
2415 : 0 : memcpy(bh->b_data + F2FS_SUPER_OFFSET, super, sizeof(*super));
2416 : : set_buffer_dirty(bh);
2417 : 0 : unlock_buffer(bh);
2418 : :
2419 : : /* it's rare case, we can do fua all the time */
2420 : 0 : return __sync_dirty_buffer(bh, REQ_SYNC | REQ_PREFLUSH | REQ_FUA);
2421 : : }
2422 : :
2423 : 0 : static inline bool sanity_check_area_boundary(struct f2fs_sb_info *sbi,
2424 : : struct buffer_head *bh)
2425 : : {
2426 : : struct f2fs_super_block *raw_super = (struct f2fs_super_block *)
2427 : 0 : (bh->b_data + F2FS_SUPER_OFFSET);
2428 : 0 : struct super_block *sb = sbi->sb;
2429 : 0 : u32 segment0_blkaddr = le32_to_cpu(raw_super->segment0_blkaddr);
2430 : 0 : u32 cp_blkaddr = le32_to_cpu(raw_super->cp_blkaddr);
2431 : 0 : u32 sit_blkaddr = le32_to_cpu(raw_super->sit_blkaddr);
2432 : 0 : u32 nat_blkaddr = le32_to_cpu(raw_super->nat_blkaddr);
2433 : 0 : u32 ssa_blkaddr = le32_to_cpu(raw_super->ssa_blkaddr);
2434 : 0 : u32 main_blkaddr = le32_to_cpu(raw_super->main_blkaddr);
2435 : 0 : u32 segment_count_ckpt = le32_to_cpu(raw_super->segment_count_ckpt);
2436 : 0 : u32 segment_count_sit = le32_to_cpu(raw_super->segment_count_sit);
2437 : 0 : u32 segment_count_nat = le32_to_cpu(raw_super->segment_count_nat);
2438 : 0 : u32 segment_count_ssa = le32_to_cpu(raw_super->segment_count_ssa);
2439 : 0 : u32 segment_count_main = le32_to_cpu(raw_super->segment_count_main);
2440 : 0 : u32 segment_count = le32_to_cpu(raw_super->segment_count);
2441 : 0 : u32 log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
2442 : 0 : u64 main_end_blkaddr = main_blkaddr +
2443 : 0 : (segment_count_main << log_blocks_per_seg);
2444 : 0 : u64 seg_end_blkaddr = segment0_blkaddr +
2445 : 0 : (segment_count << log_blocks_per_seg);
2446 : :
2447 [ # # ]: 0 : if (segment0_blkaddr != cp_blkaddr) {
2448 : 0 : f2fs_info(sbi, "Mismatch start address, segment0(%u) cp_blkaddr(%u)",
2449 : : segment0_blkaddr, cp_blkaddr);
2450 : 0 : return true;
2451 : : }
2452 : :
2453 [ # # ]: 0 : if (cp_blkaddr + (segment_count_ckpt << log_blocks_per_seg) !=
2454 : : sit_blkaddr) {
2455 : 0 : f2fs_info(sbi, "Wrong CP boundary, start(%u) end(%u) blocks(%u)",
2456 : : cp_blkaddr, sit_blkaddr,
2457 : : segment_count_ckpt << log_blocks_per_seg);
2458 : 0 : return true;
2459 : : }
2460 : :
2461 [ # # ]: 0 : if (sit_blkaddr + (segment_count_sit << log_blocks_per_seg) !=
2462 : : nat_blkaddr) {
2463 : 0 : f2fs_info(sbi, "Wrong SIT boundary, start(%u) end(%u) blocks(%u)",
2464 : : sit_blkaddr, nat_blkaddr,
2465 : : segment_count_sit << log_blocks_per_seg);
2466 : 0 : return true;
2467 : : }
2468 : :
2469 [ # # ]: 0 : if (nat_blkaddr + (segment_count_nat << log_blocks_per_seg) !=
2470 : : ssa_blkaddr) {
2471 : 0 : f2fs_info(sbi, "Wrong NAT boundary, start(%u) end(%u) blocks(%u)",
2472 : : nat_blkaddr, ssa_blkaddr,
2473 : : segment_count_nat << log_blocks_per_seg);
2474 : 0 : return true;
2475 : : }
2476 : :
2477 [ # # ]: 0 : if (ssa_blkaddr + (segment_count_ssa << log_blocks_per_seg) !=
2478 : : main_blkaddr) {
2479 : 0 : f2fs_info(sbi, "Wrong SSA boundary, start(%u) end(%u) blocks(%u)",
2480 : : ssa_blkaddr, main_blkaddr,
2481 : : segment_count_ssa << log_blocks_per_seg);
2482 : 0 : return true;
2483 : : }
2484 : :
2485 [ # # ]: 0 : if (main_end_blkaddr > seg_end_blkaddr) {
2486 : 0 : f2fs_info(sbi, "Wrong MAIN_AREA boundary, start(%u) end(%u) block(%u)",
2487 : : main_blkaddr,
2488 : : segment0_blkaddr +
2489 : : (segment_count << log_blocks_per_seg),
2490 : : segment_count_main << log_blocks_per_seg);
2491 : 0 : return true;
2492 [ # # ]: 0 : } else if (main_end_blkaddr < seg_end_blkaddr) {
2493 : : int err = 0;
2494 : : char *res;
2495 : :
2496 : : /* fix in-memory information all the time */
2497 : 0 : raw_super->segment_count = cpu_to_le32((main_end_blkaddr -
2498 : : segment0_blkaddr) >> log_blocks_per_seg);
2499 : :
2500 [ # # # # ]: 0 : if (f2fs_readonly(sb) || bdev_read_only(sb->s_bdev)) {
2501 : : set_sbi_flag(sbi, SBI_NEED_SB_WRITE);
2502 : 0 : res = "internally";
2503 : : } else {
2504 : 0 : err = __f2fs_commit_super(bh, NULL);
2505 [ # # ]: 0 : res = err ? "failed" : "done";
2506 : : }
2507 : 0 : f2fs_info(sbi, "Fix alignment : %s, start(%u) end(%u) block(%u)",
2508 : : res, main_blkaddr,
2509 : : segment0_blkaddr +
2510 : : (segment_count << log_blocks_per_seg),
2511 : : segment_count_main << log_blocks_per_seg);
2512 [ # # ]: 0 : if (err)
2513 : : return true;
2514 : : }
2515 : : return false;
2516 : : }
2517 : :
2518 : 0 : static int sanity_check_raw_super(struct f2fs_sb_info *sbi,
2519 : : struct buffer_head *bh)
2520 : : {
2521 : : block_t segment_count, segs_per_sec, secs_per_zone;
2522 : : block_t total_sections, blocks_per_seg;
2523 : 0 : struct f2fs_super_block *raw_super = (struct f2fs_super_block *)
2524 : 0 : (bh->b_data + F2FS_SUPER_OFFSET);
2525 : : unsigned int blocksize;
2526 : : size_t crc_offset = 0;
2527 : : __u32 crc = 0;
2528 : :
2529 [ # # ]: 0 : if (le32_to_cpu(raw_super->magic) != F2FS_SUPER_MAGIC) {
2530 : 0 : f2fs_info(sbi, "Magic Mismatch, valid(0x%x) - read(0x%x)",
2531 : : F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic));
2532 : 0 : return -EINVAL;
2533 : : }
2534 : :
2535 : : /* Check checksum_offset and crc in superblock */
2536 [ # # ]: 0 : if (__F2FS_HAS_FEATURE(raw_super, F2FS_FEATURE_SB_CHKSUM)) {
2537 : 0 : crc_offset = le32_to_cpu(raw_super->checksum_offset);
2538 [ # # ]: 0 : if (crc_offset !=
2539 : : offsetof(struct f2fs_super_block, crc)) {
2540 : 0 : f2fs_info(sbi, "Invalid SB checksum offset: %zu",
2541 : : crc_offset);
2542 : 0 : return -EFSCORRUPTED;
2543 : : }
2544 : 0 : crc = le32_to_cpu(raw_super->crc);
2545 [ # # ]: 0 : if (!f2fs_crc_valid(sbi, crc, raw_super, crc_offset)) {
2546 : 0 : f2fs_info(sbi, "Invalid SB checksum value: %u", crc);
2547 : 0 : return -EFSCORRUPTED;
2548 : : }
2549 : : }
2550 : :
2551 : : /* Currently, support only 4KB page cache size */
2552 : : if (F2FS_BLKSIZE != PAGE_SIZE) {
2553 : : f2fs_info(sbi, "Invalid page_cache_size (%lu), supports only 4KB",
2554 : : PAGE_SIZE);
2555 : : return -EFSCORRUPTED;
2556 : : }
2557 : :
2558 : : /* Currently, support only 4KB block size */
2559 : 0 : blocksize = 1 << le32_to_cpu(raw_super->log_blocksize);
2560 [ # # ]: 0 : if (blocksize != F2FS_BLKSIZE) {
2561 : 0 : f2fs_info(sbi, "Invalid blocksize (%u), supports only 4KB",
2562 : : blocksize);
2563 : 0 : return -EFSCORRUPTED;
2564 : : }
2565 : :
2566 : : /* check log blocks per segment */
2567 [ # # ]: 0 : if (le32_to_cpu(raw_super->log_blocks_per_seg) != 9) {
2568 : 0 : f2fs_info(sbi, "Invalid log blocks per segment (%u)",
2569 : : le32_to_cpu(raw_super->log_blocks_per_seg));
2570 : 0 : return -EFSCORRUPTED;
2571 : : }
2572 : :
2573 : : /* Currently, support 512/1024/2048/4096 bytes sector size */
2574 [ # # ]: 0 : if (le32_to_cpu(raw_super->log_sectorsize) >
2575 : 0 : F2FS_MAX_LOG_SECTOR_SIZE ||
2576 : : le32_to_cpu(raw_super->log_sectorsize) <
2577 : : F2FS_MIN_LOG_SECTOR_SIZE) {
2578 : 0 : f2fs_info(sbi, "Invalid log sectorsize (%u)",
2579 : : le32_to_cpu(raw_super->log_sectorsize));
2580 : 0 : return -EFSCORRUPTED;
2581 : : }
2582 [ # # ]: 0 : if (le32_to_cpu(raw_super->log_sectors_per_block) +
2583 : : le32_to_cpu(raw_super->log_sectorsize) !=
2584 : : F2FS_MAX_LOG_SECTOR_SIZE) {
2585 : 0 : f2fs_info(sbi, "Invalid log sectors per block(%u) log sectorsize(%u)",
2586 : : le32_to_cpu(raw_super->log_sectors_per_block),
2587 : : le32_to_cpu(raw_super->log_sectorsize));
2588 : 0 : return -EFSCORRUPTED;
2589 : : }
2590 : :
2591 : 0 : segment_count = le32_to_cpu(raw_super->segment_count);
2592 : 0 : segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
2593 : 0 : secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
2594 : 0 : total_sections = le32_to_cpu(raw_super->section_count);
2595 : :
2596 : : /* blocks_per_seg should be 512, given the above check */
2597 : 0 : blocks_per_seg = 1 << le32_to_cpu(raw_super->log_blocks_per_seg);
2598 : :
2599 [ # # ]: 0 : if (segment_count > F2FS_MAX_SEGMENT ||
2600 : : segment_count < F2FS_MIN_SEGMENTS) {
2601 : 0 : f2fs_info(sbi, "Invalid segment count (%u)", segment_count);
2602 : 0 : return -EFSCORRUPTED;
2603 : : }
2604 : :
2605 [ # # ]: 0 : if (total_sections > segment_count ||
2606 : 0 : total_sections < F2FS_MIN_SEGMENTS ||
2607 [ # # ]: 0 : segs_per_sec > segment_count || !segs_per_sec) {
2608 : 0 : f2fs_info(sbi, "Invalid segment/section count (%u, %u x %u)",
2609 : : segment_count, total_sections, segs_per_sec);
2610 : 0 : return -EFSCORRUPTED;
2611 : : }
2612 : :
2613 [ # # ]: 0 : if ((segment_count / segs_per_sec) < total_sections) {
2614 : 0 : f2fs_info(sbi, "Small segment_count (%u < %u * %u)",
2615 : : segment_count, segs_per_sec, total_sections);
2616 : 0 : return -EFSCORRUPTED;
2617 : : }
2618 : :
2619 [ # # ]: 0 : if (segment_count > (le64_to_cpu(raw_super->block_count) >> 9)) {
2620 : 0 : f2fs_info(sbi, "Wrong segment_count / block_count (%u > %llu)",
2621 : : segment_count, le64_to_cpu(raw_super->block_count));
2622 : 0 : return -EFSCORRUPTED;
2623 : : }
2624 : :
2625 [ # # ]: 0 : if (secs_per_zone > total_sections || !secs_per_zone) {
2626 : 0 : f2fs_info(sbi, "Wrong secs_per_zone / total_sections (%u, %u)",
2627 : : secs_per_zone, total_sections);
2628 : 0 : return -EFSCORRUPTED;
2629 : : }
2630 [ # # # # ]: 0 : if (le32_to_cpu(raw_super->extension_count) > F2FS_MAX_EXTENSION ||
2631 [ # # ]: 0 : raw_super->hot_ext_count > F2FS_MAX_EXTENSION ||
2632 : 0 : (le32_to_cpu(raw_super->extension_count) +
2633 : : raw_super->hot_ext_count) > F2FS_MAX_EXTENSION) {
2634 : 0 : f2fs_info(sbi, "Corrupted extension count (%u + %u > %u)",
2635 : : le32_to_cpu(raw_super->extension_count),
2636 : : raw_super->hot_ext_count,
2637 : : F2FS_MAX_EXTENSION);
2638 : 0 : return -EFSCORRUPTED;
2639 : : }
2640 : :
2641 [ # # ]: 0 : if (le32_to_cpu(raw_super->cp_payload) >
2642 : 0 : (blocks_per_seg - F2FS_CP_PACKS)) {
2643 : 0 : f2fs_info(sbi, "Insane cp_payload (%u > %u)",
2644 : : le32_to_cpu(raw_super->cp_payload),
2645 : : blocks_per_seg - F2FS_CP_PACKS);
2646 : 0 : return -EFSCORRUPTED;
2647 : : }
2648 : :
2649 : : /* check reserved ino info */
2650 [ # # # # ]: 0 : if (le32_to_cpu(raw_super->node_ino) != 1 ||
2651 [ # # ]: 0 : le32_to_cpu(raw_super->meta_ino) != 2 ||
2652 : 0 : le32_to_cpu(raw_super->root_ino) != 3) {
2653 : 0 : f2fs_info(sbi, "Invalid Fs Meta Ino: node(%u) meta(%u) root(%u)",
2654 : : le32_to_cpu(raw_super->node_ino),
2655 : : le32_to_cpu(raw_super->meta_ino),
2656 : : le32_to_cpu(raw_super->root_ino));
2657 : 0 : return -EFSCORRUPTED;
2658 : : }
2659 : :
2660 : : /* check CP/SIT/NAT/SSA/MAIN_AREA area boundary */
2661 [ # # ]: 0 : if (sanity_check_area_boundary(sbi, bh))
2662 : : return -EFSCORRUPTED;
2663 : :
2664 : 0 : return 0;
2665 : : }
2666 : :
2667 : 0 : int f2fs_sanity_check_ckpt(struct f2fs_sb_info *sbi)
2668 : : {
2669 : : unsigned int total, fsmeta;
2670 : : struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
2671 : : struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
2672 : : unsigned int ovp_segments, reserved_segments;
2673 : : unsigned int main_segs, blocks_per_seg;
2674 : : unsigned int sit_segs, nat_segs;
2675 : : unsigned int sit_bitmap_size, nat_bitmap_size;
2676 : : unsigned int log_blocks_per_seg;
2677 : : unsigned int segment_count_main;
2678 : : unsigned int cp_pack_start_sum, cp_payload;
2679 : : block_t user_block_count, valid_user_blocks;
2680 : : block_t avail_node_count, valid_node_count;
2681 : : int i, j;
2682 : :
2683 : 0 : total = le32_to_cpu(raw_super->segment_count);
2684 : 0 : fsmeta = le32_to_cpu(raw_super->segment_count_ckpt);
2685 : 0 : sit_segs = le32_to_cpu(raw_super->segment_count_sit);
2686 : 0 : fsmeta += sit_segs;
2687 : 0 : nat_segs = le32_to_cpu(raw_super->segment_count_nat);
2688 : 0 : fsmeta += nat_segs;
2689 : 0 : fsmeta += le32_to_cpu(ckpt->rsvd_segment_count);
2690 : 0 : fsmeta += le32_to_cpu(raw_super->segment_count_ssa);
2691 : :
2692 [ # # ]: 0 : if (unlikely(fsmeta >= total))
2693 : : return 1;
2694 : :
2695 : 0 : ovp_segments = le32_to_cpu(ckpt->overprov_segment_count);
2696 : : reserved_segments = le32_to_cpu(ckpt->rsvd_segment_count);
2697 : :
2698 [ # # # # ]: 0 : if (unlikely(fsmeta < F2FS_MIN_SEGMENTS ||
2699 : : ovp_segments == 0 || reserved_segments == 0)) {
2700 : 0 : f2fs_err(sbi, "Wrong layout: check mkfs.f2fs version");
2701 : 0 : return 1;
2702 : : }
2703 : :
2704 : 0 : user_block_count = le64_to_cpu(ckpt->user_block_count);
2705 : 0 : segment_count_main = le32_to_cpu(raw_super->segment_count_main);
2706 : 0 : log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
2707 [ # # # # ]: 0 : if (!user_block_count || user_block_count >=
2708 : 0 : segment_count_main << log_blocks_per_seg) {
2709 : 0 : f2fs_err(sbi, "Wrong user_block_count: %u",
2710 : : user_block_count);
2711 : 0 : return 1;
2712 : : }
2713 : :
2714 : 0 : valid_user_blocks = le64_to_cpu(ckpt->valid_block_count);
2715 [ # # ]: 0 : if (valid_user_blocks > user_block_count) {
2716 : 0 : f2fs_err(sbi, "Wrong valid_user_blocks: %u, user_block_count: %u",
2717 : : valid_user_blocks, user_block_count);
2718 : 0 : return 1;
2719 : : }
2720 : :
2721 : 0 : valid_node_count = le32_to_cpu(ckpt->valid_node_count);
2722 : 0 : avail_node_count = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;
2723 [ # # ]: 0 : if (valid_node_count > avail_node_count) {
2724 : 0 : f2fs_err(sbi, "Wrong valid_node_count: %u, avail_node_count: %u",
2725 : : valid_node_count, avail_node_count);
2726 : 0 : return 1;
2727 : : }
2728 : :
2729 : : main_segs = le32_to_cpu(raw_super->segment_count_main);
2730 : 0 : blocks_per_seg = sbi->blocks_per_seg;
2731 : :
2732 [ # # ]: 0 : for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
2733 [ # # # # ]: 0 : if (le32_to_cpu(ckpt->cur_node_segno[i]) >= main_segs ||
2734 : 0 : le16_to_cpu(ckpt->cur_node_blkoff[i]) >= blocks_per_seg)
2735 : : return 1;
2736 [ # # ]: 0 : for (j = i + 1; j < NR_CURSEG_NODE_TYPE; j++) {
2737 [ # # ]: 0 : if (le32_to_cpu(ckpt->cur_node_segno[i]) ==
2738 : 0 : le32_to_cpu(ckpt->cur_node_segno[j])) {
2739 : 0 : f2fs_err(sbi, "Node segment (%u, %u) has the same segno: %u",
2740 : : i, j,
2741 : : le32_to_cpu(ckpt->cur_node_segno[i]));
2742 : 0 : return 1;
2743 : : }
2744 : : }
2745 : : }
2746 [ # # ]: 0 : for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) {
2747 [ # # # # ]: 0 : if (le32_to_cpu(ckpt->cur_data_segno[i]) >= main_segs ||
2748 : 0 : le16_to_cpu(ckpt->cur_data_blkoff[i]) >= blocks_per_seg)
2749 : : return 1;
2750 [ # # ]: 0 : for (j = i + 1; j < NR_CURSEG_DATA_TYPE; j++) {
2751 [ # # ]: 0 : if (le32_to_cpu(ckpt->cur_data_segno[i]) ==
2752 : 0 : le32_to_cpu(ckpt->cur_data_segno[j])) {
2753 : 0 : f2fs_err(sbi, "Data segment (%u, %u) has the same segno: %u",
2754 : : i, j,
2755 : : le32_to_cpu(ckpt->cur_data_segno[i]));
2756 : 0 : return 1;
2757 : : }
2758 : : }
2759 : : }
2760 [ # # ]: 0 : for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
2761 [ # # ]: 0 : for (j = 0; j < NR_CURSEG_DATA_TYPE; j++) {
2762 [ # # ]: 0 : if (le32_to_cpu(ckpt->cur_node_segno[i]) ==
2763 : 0 : le32_to_cpu(ckpt->cur_data_segno[j])) {
2764 : 0 : f2fs_err(sbi, "Node segment (%u) and Data segment (%u) has the same segno: %u",
2765 : : i, j,
2766 : : le32_to_cpu(ckpt->cur_node_segno[i]));
2767 : 0 : return 1;
2768 : : }
2769 : : }
2770 : : }
2771 : :
2772 : 0 : sit_bitmap_size = le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);
2773 : 0 : nat_bitmap_size = le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);
2774 : :
2775 [ # # # # ]: 0 : if (sit_bitmap_size != ((sit_segs / 2) << log_blocks_per_seg) / 8 ||
2776 : 0 : nat_bitmap_size != ((nat_segs / 2) << log_blocks_per_seg) / 8) {
2777 : 0 : f2fs_err(sbi, "Wrong bitmap size: sit: %u, nat:%u",
2778 : : sit_bitmap_size, nat_bitmap_size);
2779 : 0 : return 1;
2780 : : }
2781 : :
2782 : : cp_pack_start_sum = __start_sum_addr(sbi);
2783 : : cp_payload = __cp_payload(sbi);
2784 [ # # # # ]: 0 : if (cp_pack_start_sum < cp_payload + 1 ||
2785 : 0 : cp_pack_start_sum > blocks_per_seg - 1 -
2786 : : NR_CURSEG_TYPE) {
2787 : 0 : f2fs_err(sbi, "Wrong cp_pack_start_sum: %u",
2788 : : cp_pack_start_sum);
2789 : 0 : return 1;
2790 : : }
2791 : :
2792 [ # # # # ]: 0 : if (__is_set_ckpt_flags(ckpt, CP_LARGE_NAT_BITMAP_FLAG) &&
2793 : 0 : le32_to_cpu(ckpt->checksum_offset) != CP_MIN_CHKSUM_OFFSET) {
2794 : 0 : f2fs_warn(sbi, "using deprecated layout of large_nat_bitmap, "
2795 : : "please run fsck v1.13.0 or higher to repair, chksum_offset: %u, "
2796 : : "fixed with patch: \"f2fs-tools: relocate chksum_offset for large_nat_bitmap feature\"",
2797 : : le32_to_cpu(ckpt->checksum_offset));
2798 : 0 : return 1;
2799 : : }
2800 : :
2801 [ # # ]: 0 : if (unlikely(f2fs_cp_error(sbi))) {
2802 : 0 : f2fs_err(sbi, "A bug case: need to run fsck");
2803 : 0 : return 1;
2804 : : }
2805 : : return 0;
2806 : : }
2807 : :
2808 : 0 : static void init_sb_info(struct f2fs_sb_info *sbi)
2809 : : {
2810 : 0 : struct f2fs_super_block *raw_super = sbi->raw_super;
2811 : : int i;
2812 : :
2813 : 0 : sbi->log_sectors_per_block =
2814 : 0 : le32_to_cpu(raw_super->log_sectors_per_block);
2815 : 0 : sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize);
2816 : 0 : sbi->blocksize = 1 << sbi->log_blocksize;
2817 : 0 : sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
2818 : 0 : sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg;
2819 : 0 : sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
2820 : 0 : sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
2821 : 0 : sbi->total_sections = le32_to_cpu(raw_super->section_count);
2822 : 0 : sbi->total_node_count =
2823 : 0 : (le32_to_cpu(raw_super->segment_count_nat) / 2)
2824 : 0 : * sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK;
2825 : 0 : sbi->root_ino_num = le32_to_cpu(raw_super->root_ino);
2826 : 0 : sbi->node_ino_num = le32_to_cpu(raw_super->node_ino);
2827 : 0 : sbi->meta_ino_num = le32_to_cpu(raw_super->meta_ino);
2828 : 0 : sbi->cur_victim_sec = NULL_SECNO;
2829 : 0 : sbi->next_victim_seg[BG_GC] = NULL_SEGNO;
2830 : 0 : sbi->next_victim_seg[FG_GC] = NULL_SEGNO;
2831 : 0 : sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH;
2832 : 0 : sbi->migration_granularity = sbi->segs_per_sec;
2833 : :
2834 : 0 : sbi->dir_level = DEF_DIR_LEVEL;
2835 : 0 : sbi->interval_time[CP_TIME] = DEF_CP_INTERVAL;
2836 : 0 : sbi->interval_time[REQ_TIME] = DEF_IDLE_INTERVAL;
2837 : 0 : sbi->interval_time[DISCARD_TIME] = DEF_IDLE_INTERVAL;
2838 : 0 : sbi->interval_time[GC_TIME] = DEF_IDLE_INTERVAL;
2839 : 0 : sbi->interval_time[DISABLE_TIME] = DEF_DISABLE_INTERVAL;
2840 : 0 : sbi->interval_time[UMOUNT_DISCARD_TIMEOUT] =
2841 : : DEF_UMOUNT_DISCARD_TIMEOUT;
2842 : : clear_sbi_flag(sbi, SBI_NEED_FSCK);
2843 : :
2844 [ # # ]: 0 : for (i = 0; i < NR_COUNT_TYPE; i++)
2845 : 0 : atomic_set(&sbi->nr_pages[i], 0);
2846 : :
2847 [ # # ]: 0 : for (i = 0; i < META; i++)
2848 : 0 : atomic_set(&sbi->wb_sync_req[i], 0);
2849 : :
2850 : 0 : INIT_LIST_HEAD(&sbi->s_list);
2851 : 0 : mutex_init(&sbi->umount_mutex);
2852 : 0 : init_rwsem(&sbi->io_order_lock);
2853 : 0 : spin_lock_init(&sbi->cp_lock);
2854 : :
2855 : 0 : sbi->dirty_device = 0;
2856 : 0 : spin_lock_init(&sbi->dev_lock);
2857 : :
2858 : 0 : init_rwsem(&sbi->sb_lock);
2859 : 0 : }
2860 : :
2861 : 0 : static int init_percpu_info(struct f2fs_sb_info *sbi)
2862 : : {
2863 : : int err;
2864 : :
2865 : 0 : err = percpu_counter_init(&sbi->alloc_valid_block_count, 0, GFP_KERNEL);
2866 [ # # ]: 0 : if (err)
2867 : : return err;
2868 : :
2869 : 0 : err = percpu_counter_init(&sbi->total_valid_inode_count, 0,
2870 : : GFP_KERNEL);
2871 [ # # ]: 0 : if (err)
2872 : 0 : percpu_counter_destroy(&sbi->alloc_valid_block_count);
2873 : :
2874 : 0 : return err;
2875 : : }
2876 : :
2877 : : #ifdef CONFIG_BLK_DEV_ZONED
2878 : : static int init_blkz_info(struct f2fs_sb_info *sbi, int devi)
2879 : : {
2880 : : struct block_device *bdev = FDEV(devi).bdev;
2881 : : sector_t nr_sectors = bdev->bd_part->nr_sects;
2882 : : sector_t sector = 0;
2883 : : struct blk_zone *zones;
2884 : : unsigned int i, nr_zones;
2885 : : unsigned int n = 0;
2886 : : int err = -EIO;
2887 : :
2888 : : if (!f2fs_sb_has_blkzoned(sbi))
2889 : : return 0;
2890 : :
2891 : : if (sbi->blocks_per_blkz && sbi->blocks_per_blkz !=
2892 : : SECTOR_TO_BLOCK(bdev_zone_sectors(bdev)))
2893 : : return -EINVAL;
2894 : : sbi->blocks_per_blkz = SECTOR_TO_BLOCK(bdev_zone_sectors(bdev));
2895 : : if (sbi->log_blocks_per_blkz && sbi->log_blocks_per_blkz !=
2896 : : __ilog2_u32(sbi->blocks_per_blkz))
2897 : : return -EINVAL;
2898 : : sbi->log_blocks_per_blkz = __ilog2_u32(sbi->blocks_per_blkz);
2899 : : FDEV(devi).nr_blkz = SECTOR_TO_BLOCK(nr_sectors) >>
2900 : : sbi->log_blocks_per_blkz;
2901 : : if (nr_sectors & (bdev_zone_sectors(bdev) - 1))
2902 : : FDEV(devi).nr_blkz++;
2903 : :
2904 : : FDEV(devi).blkz_seq = f2fs_kvzalloc(sbi,
2905 : : BITS_TO_LONGS(FDEV(devi).nr_blkz)
2906 : : * sizeof(unsigned long),
2907 : : GFP_KERNEL);
2908 : : if (!FDEV(devi).blkz_seq)
2909 : : return -ENOMEM;
2910 : :
2911 : : #define F2FS_REPORT_NR_ZONES 4096
2912 : :
2913 : : zones = f2fs_kzalloc(sbi,
2914 : : array_size(F2FS_REPORT_NR_ZONES,
2915 : : sizeof(struct blk_zone)),
2916 : : GFP_KERNEL);
2917 : : if (!zones)
2918 : : return -ENOMEM;
2919 : :
2920 : : /* Get block zones type */
2921 : : while (zones && sector < nr_sectors) {
2922 : :
2923 : : nr_zones = F2FS_REPORT_NR_ZONES;
2924 : : err = blkdev_report_zones(bdev, sector, zones, &nr_zones);
2925 : : if (err)
2926 : : break;
2927 : : if (!nr_zones) {
2928 : : err = -EIO;
2929 : : break;
2930 : : }
2931 : :
2932 : : for (i = 0; i < nr_zones; i++) {
2933 : : if (zones[i].type != BLK_ZONE_TYPE_CONVENTIONAL)
2934 : : set_bit(n, FDEV(devi).blkz_seq);
2935 : : sector += zones[i].len;
2936 : : n++;
2937 : : }
2938 : : }
2939 : :
2940 : : kvfree(zones);
2941 : :
2942 : : return err;
2943 : : }
2944 : : #endif
2945 : :
2946 : : /*
2947 : : * Read f2fs raw super block.
2948 : : * Because we have two copies of super block, so read both of them
2949 : : * to get the first valid one. If any one of them is broken, we pass
2950 : : * them recovery flag back to the caller.
2951 : : */
2952 : 0 : static int read_raw_super_block(struct f2fs_sb_info *sbi,
2953 : : struct f2fs_super_block **raw_super,
2954 : : int *valid_super_block, int *recovery)
2955 : : {
2956 : 0 : struct super_block *sb = sbi->sb;
2957 : : int block;
2958 : : struct buffer_head *bh;
2959 : : struct f2fs_super_block *super;
2960 : : int err = 0;
2961 : :
2962 : 0 : super = kzalloc(sizeof(struct f2fs_super_block), GFP_KERNEL);
2963 [ # # ]: 0 : if (!super)
2964 : : return -ENOMEM;
2965 : :
2966 [ # # ]: 0 : for (block = 0; block < 2; block++) {
2967 : 0 : bh = sb_bread(sb, block);
2968 [ # # ]: 0 : if (!bh) {
2969 : 0 : f2fs_err(sbi, "Unable to read %dth superblock",
2970 : : block + 1);
2971 : : err = -EIO;
2972 : 0 : continue;
2973 : : }
2974 : :
2975 : : /* sanity checking of raw super */
2976 : 0 : err = sanity_check_raw_super(sbi, bh);
2977 [ # # ]: 0 : if (err) {
2978 : 0 : f2fs_err(sbi, "Can't find valid F2FS filesystem in %dth superblock",
2979 : : block + 1);
2980 : : brelse(bh);
2981 : 0 : continue;
2982 : : }
2983 : :
2984 [ # # ]: 0 : if (!*raw_super) {
2985 : 0 : memcpy(super, bh->b_data + F2FS_SUPER_OFFSET,
2986 : : sizeof(*super));
2987 : 0 : *valid_super_block = block;
2988 : 0 : *raw_super = super;
2989 : : }
2990 : : brelse(bh);
2991 : : }
2992 : :
2993 : : /* Fail to read any one of the superblocks*/
2994 [ # # ]: 0 : if (err < 0)
2995 : 0 : *recovery = 1;
2996 : :
2997 : : /* No valid superblock */
2998 [ # # ]: 0 : if (!*raw_super)
2999 : 0 : kvfree(super);
3000 : : else
3001 : : err = 0;
3002 : :
3003 : 0 : return err;
3004 : : }
3005 : :
3006 : 0 : int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover)
3007 : : {
3008 : : struct buffer_head *bh;
3009 : : __u32 crc = 0;
3010 : : int err;
3011 : :
3012 [ # # # # : 0 : if ((recover && f2fs_readonly(sbi->sb)) ||
# # ]
3013 : 0 : bdev_read_only(sbi->sb->s_bdev)) {
3014 : : set_sbi_flag(sbi, SBI_NEED_SB_WRITE);
3015 : 0 : return -EROFS;
3016 : : }
3017 : :
3018 : : /* we should update superblock crc here */
3019 [ # # # # ]: 0 : if (!recover && f2fs_sb_has_sb_chksum(sbi)) {
3020 : : crc = f2fs_crc32(sbi, F2FS_RAW_SUPER(sbi),
3021 : : offsetof(struct f2fs_super_block, crc));
3022 : 0 : F2FS_RAW_SUPER(sbi)->crc = cpu_to_le32(crc);
3023 : : }
3024 : :
3025 : : /* write back-up superblock first */
3026 : 0 : bh = sb_bread(sbi->sb, sbi->valid_super_block ? 0 : 1);
3027 [ # # ]: 0 : if (!bh)
3028 : : return -EIO;
3029 : 0 : err = __f2fs_commit_super(bh, F2FS_RAW_SUPER(sbi));
3030 : : brelse(bh);
3031 : :
3032 : : /* if we are in recovery path, skip writing valid superblock */
3033 [ # # ]: 0 : if (recover || err)
3034 : : return err;
3035 : :
3036 : : /* write current valid superblock */
3037 : 0 : bh = sb_bread(sbi->sb, sbi->valid_super_block);
3038 [ # # ]: 0 : if (!bh)
3039 : : return -EIO;
3040 : 0 : err = __f2fs_commit_super(bh, F2FS_RAW_SUPER(sbi));
3041 : : brelse(bh);
3042 : 0 : return err;
3043 : : }
3044 : :
3045 : 0 : static int f2fs_scan_devices(struct f2fs_sb_info *sbi)
3046 : : {
3047 : : struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
3048 : : unsigned int max_devices = MAX_DEVICES;
3049 : : int i;
3050 : :
3051 : : /* Initialize single device information */
3052 [ # # ]: 0 : if (!RDEV(0).path[0]) {
3053 [ # # ]: 0 : if (!bdev_is_zoned(sbi->sb->s_bdev))
3054 : : return 0;
3055 : : max_devices = 1;
3056 : : }
3057 : :
3058 : : /*
3059 : : * Initialize multiple devices information, or single
3060 : : * zoned block device information.
3061 : : */
3062 : 0 : sbi->devs = f2fs_kzalloc(sbi,
3063 : : array_size(max_devices,
3064 : : sizeof(struct f2fs_dev_info)),
3065 : : GFP_KERNEL);
3066 [ # # ]: 0 : if (!sbi->devs)
3067 : : return -ENOMEM;
3068 : :
3069 [ # # ]: 0 : for (i = 0; i < max_devices; i++) {
3070 : :
3071 [ # # # # ]: 0 : if (i > 0 && !RDEV(i).path[0])
3072 : : break;
3073 : :
3074 [ # # ]: 0 : if (max_devices == 1) {
3075 : : /* Single zoned block device mount */
3076 : 0 : FDEV(0).bdev =
3077 : 0 : blkdev_get_by_dev(sbi->sb->s_bdev->bd_dev,
3078 : 0 : sbi->sb->s_mode, sbi->sb->s_type);
3079 : : } else {
3080 : : /* Multi-device mount */
3081 : 0 : memcpy(FDEV(i).path, RDEV(i).path, MAX_PATH_LEN);
3082 : 0 : FDEV(i).total_segments =
3083 : 0 : le32_to_cpu(RDEV(i).total_segments);
3084 [ # # ]: 0 : if (i == 0) {
3085 : 0 : FDEV(i).start_blk = 0;
3086 : 0 : FDEV(i).end_blk = FDEV(i).start_blk +
3087 : 0 : (FDEV(i).total_segments <<
3088 : 0 : sbi->log_blocks_per_seg) - 1 +
3089 : 0 : le32_to_cpu(raw_super->segment0_blkaddr);
3090 : : } else {
3091 : 0 : FDEV(i).start_blk = FDEV(i - 1).end_blk + 1;
3092 : 0 : FDEV(i).end_blk = FDEV(i).start_blk +
3093 : 0 : (FDEV(i).total_segments <<
3094 : 0 : sbi->log_blocks_per_seg) - 1;
3095 : : }
3096 : 0 : FDEV(i).bdev = blkdev_get_by_path(FDEV(i).path,
3097 : 0 : sbi->sb->s_mode, sbi->sb->s_type);
3098 : : }
3099 [ # # ]: 0 : if (IS_ERR(FDEV(i).bdev))
3100 : 0 : return PTR_ERR(FDEV(i).bdev);
3101 : :
3102 : : /* to release errored devices */
3103 : 0 : sbi->s_ndevs = i + 1;
3104 : :
3105 : : #ifdef CONFIG_BLK_DEV_ZONED
3106 : : if (bdev_zoned_model(FDEV(i).bdev) == BLK_ZONED_HM &&
3107 : : !f2fs_sb_has_blkzoned(sbi)) {
3108 : : f2fs_err(sbi, "Zoned block device feature not enabled\n");
3109 : : return -EINVAL;
3110 : : }
3111 : : if (bdev_zoned_model(FDEV(i).bdev) != BLK_ZONED_NONE) {
3112 : : if (init_blkz_info(sbi, i)) {
3113 : : f2fs_err(sbi, "Failed to initialize F2FS blkzone information");
3114 : : return -EINVAL;
3115 : : }
3116 : : if (max_devices == 1)
3117 : : break;
3118 : : f2fs_info(sbi, "Mount Device [%2d]: %20s, %8u, %8x - %8x (zone: %s)",
3119 : : i, FDEV(i).path,
3120 : : FDEV(i).total_segments,
3121 : : FDEV(i).start_blk, FDEV(i).end_blk,
3122 : : bdev_zoned_model(FDEV(i).bdev) == BLK_ZONED_HA ?
3123 : : "Host-aware" : "Host-managed");
3124 : : continue;
3125 : : }
3126 : : #endif
3127 : 0 : f2fs_info(sbi, "Mount Device [%2d]: %20s, %8u, %8x - %8x",
3128 : : i, FDEV(i).path,
3129 : : FDEV(i).total_segments,
3130 : : FDEV(i).start_blk, FDEV(i).end_blk);
3131 : : }
3132 : 0 : f2fs_info(sbi,
3133 : : "IO Block Size: %8d KB", F2FS_IO_SIZE_KB(sbi));
3134 : 0 : return 0;
3135 : : }
3136 : :
3137 : : static int f2fs_setup_casefold(struct f2fs_sb_info *sbi)
3138 : : {
3139 : : #ifdef CONFIG_UNICODE
3140 : : if (f2fs_sb_has_casefold(sbi) && !sbi->s_encoding) {
3141 : : const struct f2fs_sb_encodings *encoding_info;
3142 : : struct unicode_map *encoding;
3143 : : __u16 encoding_flags;
3144 : :
3145 : : if (f2fs_sb_has_encrypt(sbi)) {
3146 : : f2fs_err(sbi,
3147 : : "Can't mount with encoding and encryption");
3148 : : return -EINVAL;
3149 : : }
3150 : :
3151 : : if (f2fs_sb_read_encoding(sbi->raw_super, &encoding_info,
3152 : : &encoding_flags)) {
3153 : : f2fs_err(sbi,
3154 : : "Encoding requested by superblock is unknown");
3155 : : return -EINVAL;
3156 : : }
3157 : :
3158 : : encoding = utf8_load(encoding_info->version);
3159 : : if (IS_ERR(encoding)) {
3160 : : f2fs_err(sbi,
3161 : : "can't mount with superblock charset: %s-%s "
3162 : : "not supported by the kernel. flags: 0x%x.",
3163 : : encoding_info->name, encoding_info->version,
3164 : : encoding_flags);
3165 : : return PTR_ERR(encoding);
3166 : : }
3167 : : f2fs_info(sbi, "Using encoding defined by superblock: "
3168 : : "%s-%s with flags 0x%hx", encoding_info->name,
3169 : : encoding_info->version?:"\b", encoding_flags);
3170 : :
3171 : : sbi->s_encoding = encoding;
3172 : : sbi->s_encoding_flags = encoding_flags;
3173 : : sbi->sb->s_d_op = &f2fs_dentry_ops;
3174 : : }
3175 : : #else
3176 [ # # ]: 0 : if (f2fs_sb_has_casefold(sbi)) {
3177 : 0 : f2fs_err(sbi, "Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");
3178 : : return -EINVAL;
3179 : : }
3180 : : #endif
3181 : : return 0;
3182 : : }
3183 : :
3184 : : static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
3185 : : {
3186 : : struct f2fs_sm_info *sm_i = SM_I(sbi);
3187 : :
3188 : : /* adjust parameters according to the volume size */
3189 [ # # ]: 0 : if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
3190 : 0 : F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
3191 : 0 : sm_i->dcc_info->discard_granularity = 1;
3192 : 0 : sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
3193 : : }
3194 : :
3195 : 0 : sbi->readdir_ra = 1;
3196 : : }
3197 : :
3198 : 0 : static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
3199 : : {
3200 : : struct f2fs_sb_info *sbi;
3201 : : struct f2fs_super_block *raw_super;
3202 : : struct inode *root;
3203 : : int err;
3204 : : bool skip_recovery = false, need_fsck = false;
3205 : : char *options = NULL;
3206 : : int recovery, i, valid_super_block;
3207 : : struct curseg_info *seg_i;
3208 : : int retry_cnt = 1;
3209 : :
3210 : : try_onemore:
3211 : : err = -EINVAL;
3212 : 0 : raw_super = NULL;
3213 : 0 : valid_super_block = -1;
3214 : 0 : recovery = 0;
3215 : :
3216 : : /* allocate memory for f2fs-specific super block info */
3217 : 0 : sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
3218 [ # # ]: 0 : if (!sbi)
3219 : : return -ENOMEM;
3220 : :
3221 : 0 : sbi->sb = sb;
3222 : :
3223 : : /* Load the checksum driver */
3224 : 0 : sbi->s_chksum_driver = crypto_alloc_shash("crc32", 0, 0);
3225 [ # # ]: 0 : if (IS_ERR(sbi->s_chksum_driver)) {
3226 : 0 : f2fs_err(sbi, "Cannot load crc32 driver.");
3227 : 0 : err = PTR_ERR(sbi->s_chksum_driver);
3228 : 0 : sbi->s_chksum_driver = NULL;
3229 : 0 : goto free_sbi;
3230 : : }
3231 : :
3232 : : /* set a block size */
3233 [ # # ]: 0 : if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) {
3234 : 0 : f2fs_err(sbi, "unable to set blocksize");
3235 : 0 : goto free_sbi;
3236 : : }
3237 : :
3238 : 0 : err = read_raw_super_block(sbi, &raw_super, &valid_super_block,
3239 : : &recovery);
3240 [ # # ]: 0 : if (err)
3241 : : goto free_sbi;
3242 : :
3243 : 0 : sb->s_fs_info = sbi;
3244 : 0 : sbi->raw_super = raw_super;
3245 : :
3246 : : /* precompute checksum seed for metadata */
3247 [ # # ]: 0 : if (f2fs_sb_has_inode_chksum(sbi))
3248 : 0 : sbi->s_chksum_seed = f2fs_chksum(sbi, ~0, raw_super->uuid,
3249 : : sizeof(raw_super->uuid));
3250 : :
3251 : : /*
3252 : : * The BLKZONED feature indicates that the drive was formatted with
3253 : : * zone alignment optimization. This is optional for host-aware
3254 : : * devices, but mandatory for host-managed zoned block devices.
3255 : : */
3256 : : #ifndef CONFIG_BLK_DEV_ZONED
3257 [ # # ]: 0 : if (f2fs_sb_has_blkzoned(sbi)) {
3258 : 0 : f2fs_err(sbi, "Zoned block device support is not enabled");
3259 : : err = -EOPNOTSUPP;
3260 : 0 : goto free_sb_buf;
3261 : : }
3262 : : #endif
3263 : 0 : default_options(sbi);
3264 : : /* parse mount options */
3265 : 0 : options = kstrdup((const char *)data, GFP_KERNEL);
3266 [ # # ]: 0 : if (data && !options) {
3267 : : err = -ENOMEM;
3268 : : goto free_sb_buf;
3269 : : }
3270 : :
3271 : 0 : err = parse_options(sb, options);
3272 [ # # ]: 0 : if (err)
3273 : : goto free_options;
3274 : :
3275 : 0 : sbi->max_file_blocks = max_file_blocks();
3276 : 0 : sb->s_maxbytes = sbi->max_file_blocks <<
3277 : 0 : le32_to_cpu(raw_super->log_blocksize);
3278 : 0 : sb->s_max_links = F2FS_LINK_MAX;
3279 : :
3280 : : err = f2fs_setup_casefold(sbi);
3281 [ # # ]: 0 : if (err)
3282 : : goto free_options;
3283 : :
3284 : : #ifdef CONFIG_QUOTA
3285 : 0 : sb->dq_op = &f2fs_quota_operations;
3286 : 0 : sb->s_qcop = &f2fs_quotactl_ops;
3287 : 0 : sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;
3288 : :
3289 [ # # ]: 0 : if (f2fs_sb_has_quota_ino(sbi)) {
3290 [ # # ]: 0 : for (i = 0; i < MAXQUOTAS; i++) {
3291 [ # # ]: 0 : if (f2fs_qf_ino(sbi->sb, i))
3292 : 0 : sbi->nquota_files++;
3293 : : }
3294 : : }
3295 : : #endif
3296 : :
3297 : 0 : sb->s_op = &f2fs_sops;
3298 : : #ifdef CONFIG_FS_ENCRYPTION
3299 : 0 : sb->s_cop = &f2fs_cryptops;
3300 : : #endif
3301 : : #ifdef CONFIG_FS_VERITY
3302 : : sb->s_vop = &f2fs_verityops;
3303 : : #endif
3304 : 0 : sb->s_xattr = f2fs_xattr_handlers;
3305 : 0 : sb->s_export_op = &f2fs_export_ops;
3306 : 0 : sb->s_magic = F2FS_SUPER_MAGIC;
3307 : 0 : sb->s_time_gran = 1;
3308 [ # # ]: 0 : sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
3309 : 0 : (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
3310 : 0 : memcpy(&sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid));
3311 : 0 : sb->s_iflags |= SB_I_CGROUPWB;
3312 : :
3313 : : /* init f2fs-specific super block info */
3314 : 0 : sbi->valid_super_block = valid_super_block;
3315 : 0 : mutex_init(&sbi->gc_mutex);
3316 : 0 : mutex_init(&sbi->writepages);
3317 : 0 : mutex_init(&sbi->cp_mutex);
3318 : 0 : mutex_init(&sbi->resize_mutex);
3319 : 0 : init_rwsem(&sbi->node_write);
3320 : 0 : init_rwsem(&sbi->node_change);
3321 : :
3322 : : /* disallow all the data/node/meta page writes */
3323 : : set_sbi_flag(sbi, SBI_POR_DOING);
3324 : 0 : spin_lock_init(&sbi->stat_lock);
3325 : :
3326 : : /* init iostat info */
3327 : 0 : spin_lock_init(&sbi->iostat_lock);
3328 : 0 : sbi->iostat_enable = false;
3329 : :
3330 [ # # ]: 0 : for (i = 0; i < NR_PAGE_TYPE; i++) {
3331 [ # # ]: 0 : int n = (i == META) ? 1: NR_TEMP_TYPE;
3332 : : int j;
3333 : :
3334 : 0 : sbi->write_io[i] =
3335 : 0 : f2fs_kmalloc(sbi,
3336 : : array_size(n,
3337 : : sizeof(struct f2fs_bio_info)),
3338 : : GFP_KERNEL);
3339 [ # # ]: 0 : if (!sbi->write_io[i]) {
3340 : : err = -ENOMEM;
3341 : : goto free_bio_info;
3342 : : }
3343 : :
3344 [ # # ]: 0 : for (j = HOT; j < n; j++) {
3345 : 0 : init_rwsem(&sbi->write_io[i][j].io_rwsem);
3346 : 0 : sbi->write_io[i][j].sbi = sbi;
3347 : 0 : sbi->write_io[i][j].bio = NULL;
3348 : 0 : spin_lock_init(&sbi->write_io[i][j].io_lock);
3349 : 0 : INIT_LIST_HEAD(&sbi->write_io[i][j].io_list);
3350 : : }
3351 : : }
3352 : :
3353 : 0 : init_rwsem(&sbi->cp_rwsem);
3354 : 0 : init_rwsem(&sbi->quota_sem);
3355 : 0 : init_waitqueue_head(&sbi->cp_wait);
3356 : 0 : init_sb_info(sbi);
3357 : :
3358 : 0 : err = init_percpu_info(sbi);
3359 [ # # ]: 0 : if (err)
3360 : : goto free_bio_info;
3361 : :
3362 [ # # ]: 0 : if (F2FS_IO_ALIGNED(sbi)) {
3363 : 0 : sbi->write_io_dummy =
3364 : 0 : mempool_create_page_pool(2 * (F2FS_IO_SIZE(sbi) - 1), 0);
3365 [ # # ]: 0 : if (!sbi->write_io_dummy) {
3366 : : err = -ENOMEM;
3367 : : goto free_percpu;
3368 : : }
3369 : : }
3370 : :
3371 : : /* get an inode for meta space */
3372 : 0 : sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi));
3373 [ # # ]: 0 : if (IS_ERR(sbi->meta_inode)) {
3374 : 0 : f2fs_err(sbi, "Failed to read F2FS meta data inode");
3375 : 0 : err = PTR_ERR(sbi->meta_inode);
3376 : 0 : goto free_io_dummy;
3377 : : }
3378 : :
3379 : 0 : err = f2fs_get_valid_checkpoint(sbi);
3380 [ # # ]: 0 : if (err) {
3381 : 0 : f2fs_err(sbi, "Failed to get valid F2FS checkpoint");
3382 : 0 : goto free_meta_inode;
3383 : : }
3384 : :
3385 [ # # ]: 0 : if (__is_set_ckpt_flags(F2FS_CKPT(sbi), CP_QUOTA_NEED_FSCK_FLAG))
3386 : : set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
3387 [ # # ]: 0 : if (__is_set_ckpt_flags(F2FS_CKPT(sbi), CP_DISABLED_QUICK_FLAG)) {
3388 : : set_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);
3389 : 0 : sbi->interval_time[DISABLE_TIME] = DEF_DISABLE_QUICK_INTERVAL;
3390 : : }
3391 : :
3392 [ # # ]: 0 : if (__is_set_ckpt_flags(F2FS_CKPT(sbi), CP_FSCK_FLAG))
3393 : : set_sbi_flag(sbi, SBI_NEED_FSCK);
3394 : :
3395 : : /* Initialize device list */
3396 : 0 : err = f2fs_scan_devices(sbi);
3397 [ # # ]: 0 : if (err) {
3398 : 0 : f2fs_err(sbi, "Failed to find devices");
3399 : 0 : goto free_devices;
3400 : : }
3401 : :
3402 : 0 : sbi->total_valid_node_count =
3403 : 0 : le32_to_cpu(sbi->ckpt->valid_node_count);
3404 : 0 : percpu_counter_set(&sbi->total_valid_inode_count,
3405 : 0 : le32_to_cpu(sbi->ckpt->valid_inode_count));
3406 : 0 : sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count);
3407 : 0 : sbi->total_valid_block_count =
3408 : 0 : le64_to_cpu(sbi->ckpt->valid_block_count);
3409 : 0 : sbi->last_valid_block_count = sbi->total_valid_block_count;
3410 : 0 : sbi->reserved_blocks = 0;
3411 : 0 : sbi->current_reserved_blocks = 0;
3412 : 0 : limit_reserve_root(sbi);
3413 : 0 : adjust_unusable_cap_perc(sbi);
3414 : :
3415 [ # # ]: 0 : for (i = 0; i < NR_INODE_TYPE; i++) {
3416 : 0 : INIT_LIST_HEAD(&sbi->inode_list[i]);
3417 : 0 : spin_lock_init(&sbi->inode_lock[i]);
3418 : : }
3419 : 0 : mutex_init(&sbi->flush_lock);
3420 : :
3421 : 0 : f2fs_init_extent_cache_info(sbi);
3422 : :
3423 : 0 : f2fs_init_ino_entry_info(sbi);
3424 : :
3425 : 0 : f2fs_init_fsync_node_info(sbi);
3426 : :
3427 : : /* setup f2fs internal modules */
3428 : 0 : err = f2fs_build_segment_manager(sbi);
3429 [ # # ]: 0 : if (err) {
3430 : 0 : f2fs_err(sbi, "Failed to initialize F2FS segment manager (%d)",
3431 : : err);
3432 : 0 : goto free_sm;
3433 : : }
3434 : 0 : err = f2fs_build_node_manager(sbi);
3435 [ # # ]: 0 : if (err) {
3436 : 0 : f2fs_err(sbi, "Failed to initialize F2FS node manager (%d)",
3437 : : err);
3438 : 0 : goto free_nm;
3439 : : }
3440 : :
3441 : : /* For write statistics */
3442 [ # # ]: 0 : if (sb->s_bdev->bd_part)
3443 : 0 : sbi->sectors_written_start =
3444 [ # # ]: 0 : (u64)part_stat_read(sb->s_bdev->bd_part,
3445 : : sectors[STAT_WRITE]);
3446 : :
3447 : : /* Read accumulated write IO statistics if exists */
3448 : : seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);
3449 [ # # ]: 0 : if (__exist_node_summaries(sbi))
3450 : 0 : sbi->kbytes_written =
3451 : 0 : le64_to_cpu(seg_i->journal->info.kbytes_written);
3452 : :
3453 : 0 : f2fs_build_gc_manager(sbi);
3454 : :
3455 : 0 : err = f2fs_build_stats(sbi);
3456 [ # # ]: 0 : if (err)
3457 : : goto free_nm;
3458 : :
3459 : : /* get an inode for node space */
3460 : 0 : sbi->node_inode = f2fs_iget(sb, F2FS_NODE_INO(sbi));
3461 [ # # ]: 0 : if (IS_ERR(sbi->node_inode)) {
3462 : 0 : f2fs_err(sbi, "Failed to read node inode");
3463 : 0 : err = PTR_ERR(sbi->node_inode);
3464 : 0 : goto free_stats;
3465 : : }
3466 : :
3467 : : /* read root inode and dentry */
3468 : 0 : root = f2fs_iget(sb, F2FS_ROOT_INO(sbi));
3469 [ # # ]: 0 : if (IS_ERR(root)) {
3470 : 0 : f2fs_err(sbi, "Failed to read root inode");
3471 : : err = PTR_ERR(root);
3472 : 0 : goto free_node_inode;
3473 : : }
3474 [ # # # # : 0 : if (!S_ISDIR(root->i_mode) || !root->i_blocks ||
# # ]
3475 [ # # ]: 0 : !root->i_size || !root->i_nlink) {
3476 : 0 : iput(root);
3477 : : err = -EINVAL;
3478 : 0 : goto free_node_inode;
3479 : : }
3480 : :
3481 : 0 : sb->s_root = d_make_root(root); /* allocate root dentry */
3482 [ # # ]: 0 : if (!sb->s_root) {
3483 : : err = -ENOMEM;
3484 : : goto free_node_inode;
3485 : : }
3486 : :
3487 : 0 : err = f2fs_register_sysfs(sbi);
3488 [ # # ]: 0 : if (err)
3489 : : goto free_root_inode;
3490 : :
3491 : : #ifdef CONFIG_QUOTA
3492 : : /* Enable quota usage during mount */
3493 [ # # # # ]: 0 : if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sb)) {
3494 : 0 : err = f2fs_enable_quotas(sb);
3495 [ # # ]: 0 : if (err)
3496 : 0 : f2fs_err(sbi, "Cannot turn on quotas: error %d", err);
3497 : : }
3498 : : #endif
3499 : : /* if there are nt orphan nodes free them */
3500 : 0 : err = f2fs_recover_orphan_inodes(sbi);
3501 [ # # ]: 0 : if (err)
3502 : : goto free_meta;
3503 : :
3504 [ # # ]: 0 : if (unlikely(is_set_ckpt_flags(sbi, CP_DISABLED_FLAG)))
3505 : : goto reset_checkpoint;
3506 : :
3507 : : /* recover fsynced data */
3508 [ # # ]: 0 : if (!test_opt(sbi, DISABLE_ROLL_FORWARD) &&
3509 : : !test_opt(sbi, NORECOVERY)) {
3510 : : /*
3511 : : * mount should be failed, when device has readonly mode, and
3512 : : * previous checkpoint was not done by clean system shutdown.
3513 : : */
3514 [ # # ]: 0 : if (f2fs_hw_is_readonly(sbi)) {
3515 [ # # ]: 0 : if (!is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
3516 : : err = -EROFS;
3517 : 0 : f2fs_err(sbi, "Need to recover fsync data, but write access unavailable");
3518 : 0 : goto free_meta;
3519 : : }
3520 : 0 : f2fs_info(sbi, "write access unavailable, skipping recovery");
3521 : 0 : goto reset_checkpoint;
3522 : : }
3523 : :
3524 [ # # ]: 0 : if (need_fsck)
3525 : : set_sbi_flag(sbi, SBI_NEED_FSCK);
3526 : :
3527 [ # # ]: 0 : if (skip_recovery)
3528 : : goto reset_checkpoint;
3529 : :
3530 : 0 : err = f2fs_recover_fsync_data(sbi, false);
3531 [ # # ]: 0 : if (err < 0) {
3532 [ # # ]: 0 : if (err != -ENOMEM)
3533 : : skip_recovery = true;
3534 : : need_fsck = true;
3535 : 0 : f2fs_err(sbi, "Cannot recover all fsync data errno=%d",
3536 : : err);
3537 : 0 : goto free_meta;
3538 : : }
3539 : : } else {
3540 : 0 : err = f2fs_recover_fsync_data(sbi, true);
3541 : :
3542 [ # # # # ]: 0 : if (!f2fs_readonly(sb) && err > 0) {
3543 : : err = -EINVAL;
3544 : 0 : f2fs_err(sbi, "Need to recover fsync data");
3545 : 0 : goto free_meta;
3546 : : }
3547 : : }
3548 : : reset_checkpoint:
3549 : : /* f2fs_recover_fsync_data() cleared this already */
3550 : : clear_sbi_flag(sbi, SBI_POR_DOING);
3551 : :
3552 [ # # ]: 0 : if (test_opt(sbi, DISABLE_CHECKPOINT)) {
3553 : 0 : err = f2fs_disable_checkpoint(sbi);
3554 [ # # ]: 0 : if (err)
3555 : : goto sync_free_meta;
3556 [ # # ]: 0 : } else if (is_set_ckpt_flags(sbi, CP_DISABLED_FLAG)) {
3557 : 0 : f2fs_enable_checkpoint(sbi);
3558 : : }
3559 : :
3560 : : /*
3561 : : * If filesystem is not mounted as read-only then
3562 : : * do start the gc_thread.
3563 : : */
3564 [ # # # # ]: 0 : if (test_opt(sbi, BG_GC) && !f2fs_readonly(sb)) {
3565 : : /* After POR, we can run background GC thread.*/
3566 : 0 : err = f2fs_start_gc_thread(sbi);
3567 [ # # ]: 0 : if (err)
3568 : : goto sync_free_meta;
3569 : : }
3570 : 0 : kvfree(options);
3571 : :
3572 : : /* recover broken superblock */
3573 [ # # ]: 0 : if (recovery) {
3574 : 0 : err = f2fs_commit_super(sbi, true);
3575 [ # # ]: 0 : f2fs_info(sbi, "Try to recover %dth superblock, ret: %d",
3576 : : sbi->valid_super_block ? 1 : 2, err);
3577 : : }
3578 : :
3579 : 0 : f2fs_join_shrinker(sbi);
3580 : :
3581 : : f2fs_tuning_parameters(sbi);
3582 : :
3583 : 0 : f2fs_notice(sbi, "Mounted with checkpoint version = %llx",
3584 : : cur_cp_version(F2FS_CKPT(sbi)));
3585 : : f2fs_update_time(sbi, CP_TIME);
3586 : : f2fs_update_time(sbi, REQ_TIME);
3587 : : clear_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);
3588 : 0 : return 0;
3589 : :
3590 : : sync_free_meta:
3591 : : /* safe to flush all the data */
3592 : 0 : sync_filesystem(sbi->sb);
3593 : : retry_cnt = 0;
3594 : :
3595 : : free_meta:
3596 : : #ifdef CONFIG_QUOTA
3597 : 0 : f2fs_truncate_quota_inode_pages(sb);
3598 [ # # # # ]: 0 : if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sb))
3599 : 0 : f2fs_quota_off_umount(sbi->sb);
3600 : : #endif
3601 : : /*
3602 : : * Some dirty meta pages can be produced by f2fs_recover_orphan_inodes()
3603 : : * failed by EIO. Then, iput(node_inode) can trigger balance_fs_bg()
3604 : : * followed by f2fs_write_checkpoint() through f2fs_write_node_pages(), which
3605 : : * falls into an infinite loop in f2fs_sync_meta_pages().
3606 : : */
3607 : 0 : truncate_inode_pages_final(META_MAPPING(sbi));
3608 : : /* evict some inodes being cached by GC */
3609 : 0 : evict_inodes(sb);
3610 : 0 : f2fs_unregister_sysfs(sbi);
3611 : : free_root_inode:
3612 : 0 : dput(sb->s_root);
3613 : 0 : sb->s_root = NULL;
3614 : : free_node_inode:
3615 : 0 : f2fs_release_ino_entry(sbi, true);
3616 : 0 : truncate_inode_pages_final(NODE_MAPPING(sbi));
3617 : 0 : iput(sbi->node_inode);
3618 : 0 : sbi->node_inode = NULL;
3619 : : free_stats:
3620 : 0 : f2fs_destroy_stats(sbi);
3621 : : free_nm:
3622 : 0 : f2fs_destroy_node_manager(sbi);
3623 : : free_sm:
3624 : 0 : f2fs_destroy_segment_manager(sbi);
3625 : : free_devices:
3626 : 0 : destroy_device_list(sbi);
3627 : 0 : kvfree(sbi->ckpt);
3628 : : free_meta_inode:
3629 : 0 : make_bad_inode(sbi->meta_inode);
3630 : 0 : iput(sbi->meta_inode);
3631 : 0 : sbi->meta_inode = NULL;
3632 : : free_io_dummy:
3633 : 0 : mempool_destroy(sbi->write_io_dummy);
3634 : : free_percpu:
3635 : : destroy_percpu_info(sbi);
3636 : : free_bio_info:
3637 [ # # ]: 0 : for (i = 0; i < NR_PAGE_TYPE; i++)
3638 : 0 : kvfree(sbi->write_io[i]);
3639 : :
3640 : : #ifdef CONFIG_UNICODE
3641 : : utf8_unload(sbi->s_encoding);
3642 : : #endif
3643 : : free_options:
3644 : : #ifdef CONFIG_QUOTA
3645 [ # # ]: 0 : for (i = 0; i < MAXQUOTAS; i++)
3646 : 0 : kvfree(F2FS_OPTION(sbi).s_qf_names[i]);
3647 : : #endif
3648 : 0 : kvfree(options);
3649 : : free_sb_buf:
3650 : 0 : kvfree(raw_super);
3651 : : free_sbi:
3652 [ # # ]: 0 : if (sbi->s_chksum_driver)
3653 : : crypto_free_shash(sbi->s_chksum_driver);
3654 : 0 : kvfree(sbi);
3655 : :
3656 : : /* give only one another chance */
3657 [ # # ]: 0 : if (retry_cnt > 0 && skip_recovery) {
3658 : 0 : retry_cnt--;
3659 : 0 : shrink_dcache_sb(sb);
3660 : 0 : goto try_onemore;
3661 : : }
3662 : 0 : return err;
3663 : : }
3664 : :
3665 : 0 : static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags,
3666 : : const char *dev_name, void *data)
3667 : : {
3668 : 0 : return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super);
3669 : : }
3670 : :
3671 : 0 : static void kill_f2fs_super(struct super_block *sb)
3672 : : {
3673 [ # # ]: 0 : if (sb->s_root) {
3674 : : struct f2fs_sb_info *sbi = F2FS_SB(sb);
3675 : :
3676 : : set_sbi_flag(sbi, SBI_IS_CLOSE);
3677 : 0 : f2fs_stop_gc_thread(sbi);
3678 : 0 : f2fs_stop_discard_thread(sbi);
3679 : :
3680 [ # # # # ]: 0 : if (is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||
3681 : : !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
3682 : 0 : struct cp_control cpc = {
3683 : : .reason = CP_UMOUNT,
3684 : : };
3685 : 0 : f2fs_write_checkpoint(sbi, &cpc);
3686 : : }
3687 : :
3688 [ # # # # ]: 0 : if (is_sbi_flag_set(sbi, SBI_IS_RECOVERED) && f2fs_readonly(sb))
3689 : 0 : sb->s_flags &= ~SB_RDONLY;
3690 : : }
3691 : 0 : kill_block_super(sb);
3692 : 0 : }
3693 : :
3694 : : static struct file_system_type f2fs_fs_type = {
3695 : : .owner = THIS_MODULE,
3696 : : .name = "f2fs",
3697 : : .mount = f2fs_mount,
3698 : : .kill_sb = kill_f2fs_super,
3699 : : .fs_flags = FS_REQUIRES_DEV,
3700 : : };
3701 : : MODULE_ALIAS_FS("f2fs");
3702 : :
3703 : 207 : static int __init init_inodecache(void)
3704 : : {
3705 : 207 : f2fs_inode_cachep = kmem_cache_create("f2fs_inode_cache",
3706 : : sizeof(struct f2fs_inode_info), 0,
3707 : : SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT, NULL);
3708 [ + - ]: 207 : if (!f2fs_inode_cachep)
3709 : : return -ENOMEM;
3710 : 207 : return 0;
3711 : : }
3712 : :
3713 : : static void destroy_inodecache(void)
3714 : : {
3715 : : /*
3716 : : * Make sure all delayed rcu free inodes are flushed before we
3717 : : * destroy cache.
3718 : : */
3719 : 0 : rcu_barrier();
3720 : 0 : kmem_cache_destroy(f2fs_inode_cachep);
3721 : : }
3722 : :
3723 : 207 : static int __init init_f2fs_fs(void)
3724 : : {
3725 : : int err;
3726 : :
3727 : : if (PAGE_SIZE != F2FS_BLKSIZE) {
3728 : : printk("F2FS not supported on PAGE_SIZE(%lu) != %d\n",
3729 : : PAGE_SIZE, F2FS_BLKSIZE);
3730 : : return -EINVAL;
3731 : : }
3732 : :
3733 : : f2fs_build_trace_ios();
3734 : :
3735 : 207 : err = init_inodecache();
3736 [ + - ]: 207 : if (err)
3737 : : goto fail;
3738 : 207 : err = f2fs_create_node_manager_caches();
3739 [ + - ]: 207 : if (err)
3740 : : goto free_inodecache;
3741 : 207 : err = f2fs_create_segment_manager_caches();
3742 [ + - ]: 207 : if (err)
3743 : : goto free_node_manager_caches;
3744 : 207 : err = f2fs_create_checkpoint_caches();
3745 [ + - ]: 207 : if (err)
3746 : : goto free_segment_manager_caches;
3747 : 207 : err = f2fs_create_extent_cache();
3748 [ + - ]: 207 : if (err)
3749 : : goto free_checkpoint_caches;
3750 : 207 : err = f2fs_init_sysfs();
3751 [ + - ]: 207 : if (err)
3752 : : goto free_extent_cache;
3753 : 207 : err = register_shrinker(&f2fs_shrinker_info);
3754 [ + - ]: 207 : if (err)
3755 : : goto free_sysfs;
3756 : 207 : err = register_filesystem(&f2fs_fs_type);
3757 [ + - ]: 207 : if (err)
3758 : : goto free_shrinker;
3759 : 207 : f2fs_create_root_stats();
3760 : 207 : err = f2fs_init_post_read_processing();
3761 [ - + ]: 207 : if (err)
3762 : : goto free_root_stats;
3763 : : return 0;
3764 : :
3765 : : free_root_stats:
3766 : 0 : f2fs_destroy_root_stats();
3767 : 0 : unregister_filesystem(&f2fs_fs_type);
3768 : : free_shrinker:
3769 : 0 : unregister_shrinker(&f2fs_shrinker_info);
3770 : : free_sysfs:
3771 : 0 : f2fs_exit_sysfs();
3772 : : free_extent_cache:
3773 : 0 : f2fs_destroy_extent_cache();
3774 : : free_checkpoint_caches:
3775 : 0 : f2fs_destroy_checkpoint_caches();
3776 : : free_segment_manager_caches:
3777 : 0 : f2fs_destroy_segment_manager_caches();
3778 : : free_node_manager_caches:
3779 : 0 : f2fs_destroy_node_manager_caches();
3780 : : free_inodecache:
3781 : : destroy_inodecache();
3782 : : fail:
3783 : 0 : return err;
3784 : : }
3785 : :
3786 : 0 : static void __exit exit_f2fs_fs(void)
3787 : : {
3788 : 0 : f2fs_destroy_post_read_processing();
3789 : 0 : f2fs_destroy_root_stats();
3790 : 0 : unregister_filesystem(&f2fs_fs_type);
3791 : 0 : unregister_shrinker(&f2fs_shrinker_info);
3792 : 0 : f2fs_exit_sysfs();
3793 : 0 : f2fs_destroy_extent_cache();
3794 : 0 : f2fs_destroy_checkpoint_caches();
3795 : 0 : f2fs_destroy_segment_manager_caches();
3796 : 0 : f2fs_destroy_node_manager_caches();
3797 : : destroy_inodecache();
3798 : : f2fs_destroy_trace_ios();
3799 : 0 : }
3800 : :
3801 : : module_init(init_f2fs_fs)
3802 : : module_exit(exit_f2fs_fs)
3803 : :
3804 : : MODULE_AUTHOR("Samsung Electronics's Praesto Team");
3805 : : MODULE_DESCRIPTION("Flash Friendly File System");
3806 : : MODULE_LICENSE("GPL");
3807 : :
|
