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