1 /* 2 * fs/f2fs/super.c 3 * 4 * Copyright (c) 2012 Samsung Electronics Co., Ltd. 5 * http://www.samsung.com/ 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 #include <linux/module.h> 12 #include <linux/init.h> 13 #include <linux/fs.h> 14 #include <linux/statfs.h> 15 #include <linux/buffer_head.h> 16 #include <linux/backing-dev.h> 17 #include <linux/kthread.h> 18 #include <linux/parser.h> 19 #include <linux/mount.h> 20 #include <linux/seq_file.h> 21 #include <linux/proc_fs.h> 22 #include <linux/random.h> 23 #include <linux/exportfs.h> 24 #include <linux/blkdev.h> 25 #include <linux/quotaops.h> 26 #include <linux/f2fs_fs.h> 27 #include <linux/sysfs.h> 28 #include <linux/quota.h> 29 30 #include "f2fs.h" 31 #include "node.h" 32 #include "segment.h" 33 #include "xattr.h" 34 #include "gc.h" 35 #include "trace.h" 36 37 #define CREATE_TRACE_POINTS 38 #include <trace/events/f2fs.h> 39 40 static struct kmem_cache *f2fs_inode_cachep; 41 42 #ifdef CONFIG_F2FS_FAULT_INJECTION 43 44 char *fault_name[FAULT_MAX] = { 45 [FAULT_KMALLOC] = "kmalloc", 46 [FAULT_PAGE_ALLOC] = "page alloc", 47 [FAULT_ALLOC_NID] = "alloc nid", 48 [FAULT_ORPHAN] = "orphan", 49 [FAULT_BLOCK] = "no more block", 50 [FAULT_DIR_DEPTH] = "too big dir depth", 51 [FAULT_EVICT_INODE] = "evict_inode fail", 52 [FAULT_TRUNCATE] = "truncate fail", 53 [FAULT_IO] = "IO error", 54 [FAULT_CHECKPOINT] = "checkpoint error", 55 }; 56 57 static void f2fs_build_fault_attr(struct f2fs_sb_info *sbi, 58 unsigned int rate) 59 { 60 struct f2fs_fault_info *ffi = &sbi->fault_info; 61 62 if (rate) { 63 atomic_set(&ffi->inject_ops, 0); 64 ffi->inject_rate = rate; 65 ffi->inject_type = (1 << FAULT_MAX) - 1; 66 } else { 67 memset(ffi, 0, sizeof(struct f2fs_fault_info)); 68 } 69 } 70 #endif 71 72 /* f2fs-wide shrinker description */ 73 static struct shrinker f2fs_shrinker_info = { 74 .scan_objects = f2fs_shrink_scan, 75 .count_objects = f2fs_shrink_count, 76 .seeks = DEFAULT_SEEKS, 77 }; 78 79 enum { 80 Opt_gc_background, 81 Opt_disable_roll_forward, 82 Opt_norecovery, 83 Opt_discard, 84 Opt_nodiscard, 85 Opt_noheap, 86 Opt_heap, 87 Opt_user_xattr, 88 Opt_nouser_xattr, 89 Opt_acl, 90 Opt_noacl, 91 Opt_active_logs, 92 Opt_disable_ext_identify, 93 Opt_inline_xattr, 94 Opt_noinline_xattr, 95 Opt_inline_data, 96 Opt_inline_dentry, 97 Opt_noinline_dentry, 98 Opt_flush_merge, 99 Opt_noflush_merge, 100 Opt_nobarrier, 101 Opt_fastboot, 102 Opt_extent_cache, 103 Opt_noextent_cache, 104 Opt_noinline_data, 105 Opt_data_flush, 106 Opt_mode, 107 Opt_io_size_bits, 108 Opt_fault_injection, 109 Opt_lazytime, 110 Opt_nolazytime, 111 Opt_quota, 112 Opt_noquota, 113 Opt_usrquota, 114 Opt_grpquota, 115 Opt_prjquota, 116 Opt_usrjquota, 117 Opt_grpjquota, 118 Opt_prjjquota, 119 Opt_offusrjquota, 120 Opt_offgrpjquota, 121 Opt_offprjjquota, 122 Opt_jqfmt_vfsold, 123 Opt_jqfmt_vfsv0, 124 Opt_jqfmt_vfsv1, 125 Opt_err, 126 }; 127 128 static match_table_t f2fs_tokens = { 129 {Opt_gc_background, "background_gc=%s"}, 130 {Opt_disable_roll_forward, "disable_roll_forward"}, 131 {Opt_norecovery, "norecovery"}, 132 {Opt_discard, "discard"}, 133 {Opt_nodiscard, "nodiscard"}, 134 {Opt_noheap, "no_heap"}, 135 {Opt_heap, "heap"}, 136 {Opt_user_xattr, "user_xattr"}, 137 {Opt_nouser_xattr, "nouser_xattr"}, 138 {Opt_acl, "acl"}, 139 {Opt_noacl, "noacl"}, 140 {Opt_active_logs, "active_logs=%u"}, 141 {Opt_disable_ext_identify, "disable_ext_identify"}, 142 {Opt_inline_xattr, "inline_xattr"}, 143 {Opt_noinline_xattr, "noinline_xattr"}, 144 {Opt_inline_data, "inline_data"}, 145 {Opt_inline_dentry, "inline_dentry"}, 146 {Opt_noinline_dentry, "noinline_dentry"}, 147 {Opt_flush_merge, "flush_merge"}, 148 {Opt_noflush_merge, "noflush_merge"}, 149 {Opt_nobarrier, "nobarrier"}, 150 {Opt_fastboot, "fastboot"}, 151 {Opt_extent_cache, "extent_cache"}, 152 {Opt_noextent_cache, "noextent_cache"}, 153 {Opt_noinline_data, "noinline_data"}, 154 {Opt_data_flush, "data_flush"}, 155 {Opt_mode, "mode=%s"}, 156 {Opt_io_size_bits, "io_bits=%u"}, 157 {Opt_fault_injection, "fault_injection=%u"}, 158 {Opt_lazytime, "lazytime"}, 159 {Opt_nolazytime, "nolazytime"}, 160 {Opt_quota, "quota"}, 161 {Opt_noquota, "noquota"}, 162 {Opt_usrquota, "usrquota"}, 163 {Opt_grpquota, "grpquota"}, 164 {Opt_prjquota, "prjquota"}, 165 {Opt_usrjquota, "usrjquota=%s"}, 166 {Opt_grpjquota, "grpjquota=%s"}, 167 {Opt_prjjquota, "prjjquota=%s"}, 168 {Opt_offusrjquota, "usrjquota="}, 169 {Opt_offgrpjquota, "grpjquota="}, 170 {Opt_offprjjquota, "prjjquota="}, 171 {Opt_jqfmt_vfsold, "jqfmt=vfsold"}, 172 {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"}, 173 {Opt_jqfmt_vfsv1, "jqfmt=vfsv1"}, 174 {Opt_err, NULL}, 175 }; 176 177 void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...) 178 { 179 struct va_format vaf; 180 va_list args; 181 182 va_start(args, fmt); 183 vaf.fmt = fmt; 184 vaf.va = &args; 185 printk_ratelimited("%sF2FS-fs (%s): %pV\n", level, sb->s_id, &vaf); 186 va_end(args); 187 } 188 189 static void init_once(void *foo) 190 { 191 struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo; 192 193 inode_init_once(&fi->vfs_inode); 194 } 195 196 #ifdef CONFIG_QUOTA 197 static const char * const quotatypes[] = INITQFNAMES; 198 #define QTYPE2NAME(t) (quotatypes[t]) 199 static int f2fs_set_qf_name(struct super_block *sb, int qtype, 200 substring_t *args) 201 { 202 struct f2fs_sb_info *sbi = F2FS_SB(sb); 203 char *qname; 204 int ret = -EINVAL; 205 206 if (sb_any_quota_loaded(sb) && !sbi->s_qf_names[qtype]) { 207 f2fs_msg(sb, KERN_ERR, 208 "Cannot change journaled " 209 "quota options when quota turned on"); 210 return -EINVAL; 211 } 212 qname = match_strdup(args); 213 if (!qname) { 214 f2fs_msg(sb, KERN_ERR, 215 "Not enough memory for storing quotafile name"); 216 return -EINVAL; 217 } 218 if (sbi->s_qf_names[qtype]) { 219 if (strcmp(sbi->s_qf_names[qtype], qname) == 0) 220 ret = 0; 221 else 222 f2fs_msg(sb, KERN_ERR, 223 "%s quota file already specified", 224 QTYPE2NAME(qtype)); 225 goto errout; 226 } 227 if (strchr(qname, '/')) { 228 f2fs_msg(sb, KERN_ERR, 229 "quotafile must be on filesystem root"); 230 goto errout; 231 } 232 sbi->s_qf_names[qtype] = qname; 233 set_opt(sbi, QUOTA); 234 return 0; 235 errout: 236 kfree(qname); 237 return ret; 238 } 239 240 static int f2fs_clear_qf_name(struct super_block *sb, int qtype) 241 { 242 struct f2fs_sb_info *sbi = F2FS_SB(sb); 243 244 if (sb_any_quota_loaded(sb) && sbi->s_qf_names[qtype]) { 245 f2fs_msg(sb, KERN_ERR, "Cannot change journaled quota options" 246 " when quota turned on"); 247 return -EINVAL; 248 } 249 kfree(sbi->s_qf_names[qtype]); 250 sbi->s_qf_names[qtype] = NULL; 251 return 0; 252 } 253 254 static int f2fs_check_quota_options(struct f2fs_sb_info *sbi) 255 { 256 /* 257 * We do the test below only for project quotas. 'usrquota' and 258 * 'grpquota' mount options are allowed even without quota feature 259 * to support legacy quotas in quota files. 260 */ 261 if (test_opt(sbi, PRJQUOTA) && !f2fs_sb_has_project_quota(sbi->sb)) { 262 f2fs_msg(sbi->sb, KERN_ERR, "Project quota feature not enabled. " 263 "Cannot enable project quota enforcement."); 264 return -1; 265 } 266 if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA] || 267 sbi->s_qf_names[PRJQUOTA]) { 268 if (test_opt(sbi, USRQUOTA) && sbi->s_qf_names[USRQUOTA]) 269 clear_opt(sbi, USRQUOTA); 270 271 if (test_opt(sbi, GRPQUOTA) && sbi->s_qf_names[GRPQUOTA]) 272 clear_opt(sbi, GRPQUOTA); 273 274 if (test_opt(sbi, PRJQUOTA) && sbi->s_qf_names[PRJQUOTA]) 275 clear_opt(sbi, PRJQUOTA); 276 277 if (test_opt(sbi, GRPQUOTA) || test_opt(sbi, USRQUOTA) || 278 test_opt(sbi, PRJQUOTA)) { 279 f2fs_msg(sbi->sb, KERN_ERR, "old and new quota " 280 "format mixing"); 281 return -1; 282 } 283 284 if (!sbi->s_jquota_fmt) { 285 f2fs_msg(sbi->sb, KERN_ERR, "journaled quota format " 286 "not specified"); 287 return -1; 288 } 289 } 290 return 0; 291 } 292 #endif 293 294 static int parse_options(struct super_block *sb, char *options) 295 { 296 struct f2fs_sb_info *sbi = F2FS_SB(sb); 297 struct request_queue *q; 298 substring_t args[MAX_OPT_ARGS]; 299 char *p, *name; 300 int arg = 0; 301 #ifdef CONFIG_QUOTA 302 int ret; 303 #endif 304 305 if (!options) 306 return 0; 307 308 while ((p = strsep(&options, ",")) != NULL) { 309 int token; 310 if (!*p) 311 continue; 312 /* 313 * Initialize args struct so we know whether arg was 314 * found; some options take optional arguments. 315 */ 316 args[0].to = args[0].from = NULL; 317 token = match_token(p, f2fs_tokens, args); 318 319 switch (token) { 320 case Opt_gc_background: 321 name = match_strdup(&args[0]); 322 323 if (!name) 324 return -ENOMEM; 325 if (strlen(name) == 2 && !strncmp(name, "on", 2)) { 326 set_opt(sbi, BG_GC); 327 clear_opt(sbi, FORCE_FG_GC); 328 } else if (strlen(name) == 3 && !strncmp(name, "off", 3)) { 329 clear_opt(sbi, BG_GC); 330 clear_opt(sbi, FORCE_FG_GC); 331 } else if (strlen(name) == 4 && !strncmp(name, "sync", 4)) { 332 set_opt(sbi, BG_GC); 333 set_opt(sbi, FORCE_FG_GC); 334 } else { 335 kfree(name); 336 return -EINVAL; 337 } 338 kfree(name); 339 break; 340 case Opt_disable_roll_forward: 341 set_opt(sbi, DISABLE_ROLL_FORWARD); 342 break; 343 case Opt_norecovery: 344 /* this option mounts f2fs with ro */ 345 set_opt(sbi, DISABLE_ROLL_FORWARD); 346 if (!f2fs_readonly(sb)) 347 return -EINVAL; 348 break; 349 case Opt_discard: 350 q = bdev_get_queue(sb->s_bdev); 351 if (blk_queue_discard(q)) { 352 set_opt(sbi, DISCARD); 353 } else if (!f2fs_sb_mounted_blkzoned(sb)) { 354 f2fs_msg(sb, KERN_WARNING, 355 "mounting with \"discard\" option, but " 356 "the device does not support discard"); 357 } 358 break; 359 case Opt_nodiscard: 360 if (f2fs_sb_mounted_blkzoned(sb)) { 361 f2fs_msg(sb, KERN_WARNING, 362 "discard is required for zoned block devices"); 363 return -EINVAL; 364 } 365 clear_opt(sbi, DISCARD); 366 break; 367 case Opt_noheap: 368 set_opt(sbi, NOHEAP); 369 break; 370 case Opt_heap: 371 clear_opt(sbi, NOHEAP); 372 break; 373 #ifdef CONFIG_F2FS_FS_XATTR 374 case Opt_user_xattr: 375 set_opt(sbi, XATTR_USER); 376 break; 377 case Opt_nouser_xattr: 378 clear_opt(sbi, XATTR_USER); 379 break; 380 case Opt_inline_xattr: 381 set_opt(sbi, INLINE_XATTR); 382 break; 383 case Opt_noinline_xattr: 384 clear_opt(sbi, INLINE_XATTR); 385 break; 386 #else 387 case Opt_user_xattr: 388 f2fs_msg(sb, KERN_INFO, 389 "user_xattr options not supported"); 390 break; 391 case Opt_nouser_xattr: 392 f2fs_msg(sb, KERN_INFO, 393 "nouser_xattr options not supported"); 394 break; 395 case Opt_inline_xattr: 396 f2fs_msg(sb, KERN_INFO, 397 "inline_xattr options not supported"); 398 break; 399 case Opt_noinline_xattr: 400 f2fs_msg(sb, KERN_INFO, 401 "noinline_xattr options not supported"); 402 break; 403 #endif 404 #ifdef CONFIG_F2FS_FS_POSIX_ACL 405 case Opt_acl: 406 set_opt(sbi, POSIX_ACL); 407 break; 408 case Opt_noacl: 409 clear_opt(sbi, POSIX_ACL); 410 break; 411 #else 412 case Opt_acl: 413 f2fs_msg(sb, KERN_INFO, "acl options not supported"); 414 break; 415 case Opt_noacl: 416 f2fs_msg(sb, KERN_INFO, "noacl options not supported"); 417 break; 418 #endif 419 case Opt_active_logs: 420 if (args->from && match_int(args, &arg)) 421 return -EINVAL; 422 if (arg != 2 && arg != 4 && arg != NR_CURSEG_TYPE) 423 return -EINVAL; 424 sbi->active_logs = arg; 425 break; 426 case Opt_disable_ext_identify: 427 set_opt(sbi, DISABLE_EXT_IDENTIFY); 428 break; 429 case Opt_inline_data: 430 set_opt(sbi, INLINE_DATA); 431 break; 432 case Opt_inline_dentry: 433 set_opt(sbi, INLINE_DENTRY); 434 break; 435 case Opt_noinline_dentry: 436 clear_opt(sbi, INLINE_DENTRY); 437 break; 438 case Opt_flush_merge: 439 set_opt(sbi, FLUSH_MERGE); 440 break; 441 case Opt_noflush_merge: 442 clear_opt(sbi, FLUSH_MERGE); 443 break; 444 case Opt_nobarrier: 445 set_opt(sbi, NOBARRIER); 446 break; 447 case Opt_fastboot: 448 set_opt(sbi, FASTBOOT); 449 break; 450 case Opt_extent_cache: 451 set_opt(sbi, EXTENT_CACHE); 452 break; 453 case Opt_noextent_cache: 454 clear_opt(sbi, EXTENT_CACHE); 455 break; 456 case Opt_noinline_data: 457 clear_opt(sbi, INLINE_DATA); 458 break; 459 case Opt_data_flush: 460 set_opt(sbi, DATA_FLUSH); 461 break; 462 case Opt_mode: 463 name = match_strdup(&args[0]); 464 465 if (!name) 466 return -ENOMEM; 467 if (strlen(name) == 8 && 468 !strncmp(name, "adaptive", 8)) { 469 if (f2fs_sb_mounted_blkzoned(sb)) { 470 f2fs_msg(sb, KERN_WARNING, 471 "adaptive mode is not allowed with " 472 "zoned block device feature"); 473 kfree(name); 474 return -EINVAL; 475 } 476 set_opt_mode(sbi, F2FS_MOUNT_ADAPTIVE); 477 } else if (strlen(name) == 3 && 478 !strncmp(name, "lfs", 3)) { 479 set_opt_mode(sbi, F2FS_MOUNT_LFS); 480 } else { 481 kfree(name); 482 return -EINVAL; 483 } 484 kfree(name); 485 break; 486 case Opt_io_size_bits: 487 if (args->from && match_int(args, &arg)) 488 return -EINVAL; 489 if (arg > __ilog2_u32(BIO_MAX_PAGES)) { 490 f2fs_msg(sb, KERN_WARNING, 491 "Not support %d, larger than %d", 492 1 << arg, BIO_MAX_PAGES); 493 return -EINVAL; 494 } 495 sbi->write_io_size_bits = arg; 496 break; 497 case Opt_fault_injection: 498 if (args->from && match_int(args, &arg)) 499 return -EINVAL; 500 #ifdef CONFIG_F2FS_FAULT_INJECTION 501 f2fs_build_fault_attr(sbi, arg); 502 set_opt(sbi, FAULT_INJECTION); 503 #else 504 f2fs_msg(sb, KERN_INFO, 505 "FAULT_INJECTION was not selected"); 506 #endif 507 break; 508 case Opt_lazytime: 509 sb->s_flags |= MS_LAZYTIME; 510 break; 511 case Opt_nolazytime: 512 sb->s_flags &= ~MS_LAZYTIME; 513 break; 514 #ifdef CONFIG_QUOTA 515 case Opt_quota: 516 case Opt_usrquota: 517 set_opt(sbi, USRQUOTA); 518 break; 519 case Opt_grpquota: 520 set_opt(sbi, GRPQUOTA); 521 break; 522 case Opt_prjquota: 523 set_opt(sbi, PRJQUOTA); 524 break; 525 case Opt_usrjquota: 526 ret = f2fs_set_qf_name(sb, USRQUOTA, &args[0]); 527 if (ret) 528 return ret; 529 break; 530 case Opt_grpjquota: 531 ret = f2fs_set_qf_name(sb, GRPQUOTA, &args[0]); 532 if (ret) 533 return ret; 534 break; 535 case Opt_prjjquota: 536 ret = f2fs_set_qf_name(sb, PRJQUOTA, &args[0]); 537 if (ret) 538 return ret; 539 break; 540 case Opt_offusrjquota: 541 ret = f2fs_clear_qf_name(sb, USRQUOTA); 542 if (ret) 543 return ret; 544 break; 545 case Opt_offgrpjquota: 546 ret = f2fs_clear_qf_name(sb, GRPQUOTA); 547 if (ret) 548 return ret; 549 break; 550 case Opt_offprjjquota: 551 ret = f2fs_clear_qf_name(sb, PRJQUOTA); 552 if (ret) 553 return ret; 554 break; 555 case Opt_jqfmt_vfsold: 556 sbi->s_jquota_fmt = QFMT_VFS_OLD; 557 break; 558 case Opt_jqfmt_vfsv0: 559 sbi->s_jquota_fmt = QFMT_VFS_V0; 560 break; 561 case Opt_jqfmt_vfsv1: 562 sbi->s_jquota_fmt = QFMT_VFS_V1; 563 break; 564 case Opt_noquota: 565 clear_opt(sbi, QUOTA); 566 clear_opt(sbi, USRQUOTA); 567 clear_opt(sbi, GRPQUOTA); 568 clear_opt(sbi, PRJQUOTA); 569 break; 570 #else 571 case Opt_quota: 572 case Opt_usrquota: 573 case Opt_grpquota: 574 case Opt_prjquota: 575 case Opt_usrjquota: 576 case Opt_grpjquota: 577 case Opt_prjjquota: 578 case Opt_offusrjquota: 579 case Opt_offgrpjquota: 580 case Opt_offprjjquota: 581 case Opt_jqfmt_vfsold: 582 case Opt_jqfmt_vfsv0: 583 case Opt_jqfmt_vfsv1: 584 case Opt_noquota: 585 f2fs_msg(sb, KERN_INFO, 586 "quota operations not supported"); 587 break; 588 #endif 589 default: 590 f2fs_msg(sb, KERN_ERR, 591 "Unrecognized mount option \"%s\" or missing value", 592 p); 593 return -EINVAL; 594 } 595 } 596 #ifdef CONFIG_QUOTA 597 if (f2fs_check_quota_options(sbi)) 598 return -EINVAL; 599 #endif 600 601 if (F2FS_IO_SIZE_BITS(sbi) && !test_opt(sbi, LFS)) { 602 f2fs_msg(sb, KERN_ERR, 603 "Should set mode=lfs with %uKB-sized IO", 604 F2FS_IO_SIZE_KB(sbi)); 605 return -EINVAL; 606 } 607 return 0; 608 } 609 610 static struct inode *f2fs_alloc_inode(struct super_block *sb) 611 { 612 struct f2fs_inode_info *fi; 613 614 fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_F2FS_ZERO); 615 if (!fi) 616 return NULL; 617 618 init_once((void *) fi); 619 620 /* Initialize f2fs-specific inode info */ 621 fi->vfs_inode.i_version = 1; 622 atomic_set(&fi->dirty_pages, 0); 623 fi->i_current_depth = 1; 624 fi->i_advise = 0; 625 init_rwsem(&fi->i_sem); 626 INIT_LIST_HEAD(&fi->dirty_list); 627 INIT_LIST_HEAD(&fi->gdirty_list); 628 INIT_LIST_HEAD(&fi->inmem_pages); 629 mutex_init(&fi->inmem_lock); 630 init_rwsem(&fi->dio_rwsem[READ]); 631 init_rwsem(&fi->dio_rwsem[WRITE]); 632 init_rwsem(&fi->i_mmap_sem); 633 init_rwsem(&fi->i_xattr_sem); 634 635 #ifdef CONFIG_QUOTA 636 memset(&fi->i_dquot, 0, sizeof(fi->i_dquot)); 637 fi->i_reserved_quota = 0; 638 #endif 639 /* Will be used by directory only */ 640 fi->i_dir_level = F2FS_SB(sb)->dir_level; 641 642 return &fi->vfs_inode; 643 } 644 645 static int f2fs_drop_inode(struct inode *inode) 646 { 647 int ret; 648 /* 649 * This is to avoid a deadlock condition like below. 650 * writeback_single_inode(inode) 651 * - f2fs_write_data_page 652 * - f2fs_gc -> iput -> evict 653 * - inode_wait_for_writeback(inode) 654 */ 655 if ((!inode_unhashed(inode) && inode->i_state & I_SYNC)) { 656 if (!inode->i_nlink && !is_bad_inode(inode)) { 657 /* to avoid evict_inode call simultaneously */ 658 atomic_inc(&inode->i_count); 659 spin_unlock(&inode->i_lock); 660 661 /* some remained atomic pages should discarded */ 662 if (f2fs_is_atomic_file(inode)) 663 drop_inmem_pages(inode); 664 665 /* should remain fi->extent_tree for writepage */ 666 f2fs_destroy_extent_node(inode); 667 668 sb_start_intwrite(inode->i_sb); 669 f2fs_i_size_write(inode, 0); 670 671 if (F2FS_HAS_BLOCKS(inode)) 672 f2fs_truncate(inode); 673 674 sb_end_intwrite(inode->i_sb); 675 676 fscrypt_put_encryption_info(inode, NULL); 677 spin_lock(&inode->i_lock); 678 atomic_dec(&inode->i_count); 679 } 680 trace_f2fs_drop_inode(inode, 0); 681 return 0; 682 } 683 ret = generic_drop_inode(inode); 684 trace_f2fs_drop_inode(inode, ret); 685 return ret; 686 } 687 688 int f2fs_inode_dirtied(struct inode *inode, bool sync) 689 { 690 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 691 int ret = 0; 692 693 spin_lock(&sbi->inode_lock[DIRTY_META]); 694 if (is_inode_flag_set(inode, FI_DIRTY_INODE)) { 695 ret = 1; 696 } else { 697 set_inode_flag(inode, FI_DIRTY_INODE); 698 stat_inc_dirty_inode(sbi, DIRTY_META); 699 } 700 if (sync && list_empty(&F2FS_I(inode)->gdirty_list)) { 701 list_add_tail(&F2FS_I(inode)->gdirty_list, 702 &sbi->inode_list[DIRTY_META]); 703 inc_page_count(sbi, F2FS_DIRTY_IMETA); 704 } 705 spin_unlock(&sbi->inode_lock[DIRTY_META]); 706 return ret; 707 } 708 709 void f2fs_inode_synced(struct inode *inode) 710 { 711 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 712 713 spin_lock(&sbi->inode_lock[DIRTY_META]); 714 if (!is_inode_flag_set(inode, FI_DIRTY_INODE)) { 715 spin_unlock(&sbi->inode_lock[DIRTY_META]); 716 return; 717 } 718 if (!list_empty(&F2FS_I(inode)->gdirty_list)) { 719 list_del_init(&F2FS_I(inode)->gdirty_list); 720 dec_page_count(sbi, F2FS_DIRTY_IMETA); 721 } 722 clear_inode_flag(inode, FI_DIRTY_INODE); 723 clear_inode_flag(inode, FI_AUTO_RECOVER); 724 stat_dec_dirty_inode(F2FS_I_SB(inode), DIRTY_META); 725 spin_unlock(&sbi->inode_lock[DIRTY_META]); 726 } 727 728 /* 729 * f2fs_dirty_inode() is called from __mark_inode_dirty() 730 * 731 * We should call set_dirty_inode to write the dirty inode through write_inode. 732 */ 733 static void f2fs_dirty_inode(struct inode *inode, int flags) 734 { 735 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 736 737 if (inode->i_ino == F2FS_NODE_INO(sbi) || 738 inode->i_ino == F2FS_META_INO(sbi)) 739 return; 740 741 if (flags == I_DIRTY_TIME) 742 return; 743 744 if (is_inode_flag_set(inode, FI_AUTO_RECOVER)) 745 clear_inode_flag(inode, FI_AUTO_RECOVER); 746 747 f2fs_inode_dirtied(inode, false); 748 } 749 750 static void f2fs_i_callback(struct rcu_head *head) 751 { 752 struct inode *inode = container_of(head, struct inode, i_rcu); 753 kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode)); 754 } 755 756 static void f2fs_destroy_inode(struct inode *inode) 757 { 758 call_rcu(&inode->i_rcu, f2fs_i_callback); 759 } 760 761 static void destroy_percpu_info(struct f2fs_sb_info *sbi) 762 { 763 percpu_counter_destroy(&sbi->alloc_valid_block_count); 764 percpu_counter_destroy(&sbi->total_valid_inode_count); 765 } 766 767 static void destroy_device_list(struct f2fs_sb_info *sbi) 768 { 769 int i; 770 771 for (i = 0; i < sbi->s_ndevs; i++) { 772 blkdev_put(FDEV(i).bdev, FMODE_EXCL); 773 #ifdef CONFIG_BLK_DEV_ZONED 774 kfree(FDEV(i).blkz_type); 775 #endif 776 } 777 kfree(sbi->devs); 778 } 779 780 static void f2fs_put_super(struct super_block *sb) 781 { 782 struct f2fs_sb_info *sbi = F2FS_SB(sb); 783 int i; 784 785 f2fs_quota_off_umount(sb); 786 787 /* prevent remaining shrinker jobs */ 788 mutex_lock(&sbi->umount_mutex); 789 790 /* 791 * We don't need to do checkpoint when superblock is clean. 792 * But, the previous checkpoint was not done by umount, it needs to do 793 * clean checkpoint again. 794 */ 795 if (is_sbi_flag_set(sbi, SBI_IS_DIRTY) || 796 !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) { 797 struct cp_control cpc = { 798 .reason = CP_UMOUNT, 799 }; 800 write_checkpoint(sbi, &cpc); 801 } 802 803 /* be sure to wait for any on-going discard commands */ 804 f2fs_wait_discard_bios(sbi, true); 805 806 if (f2fs_discard_en(sbi) && !sbi->discard_blks) { 807 struct cp_control cpc = { 808 .reason = CP_UMOUNT | CP_TRIMMED, 809 }; 810 write_checkpoint(sbi, &cpc); 811 } 812 813 /* write_checkpoint can update stat informaion */ 814 f2fs_destroy_stats(sbi); 815 816 /* 817 * normally superblock is clean, so we need to release this. 818 * In addition, EIO will skip do checkpoint, we need this as well. 819 */ 820 release_ino_entry(sbi, true); 821 822 f2fs_leave_shrinker(sbi); 823 mutex_unlock(&sbi->umount_mutex); 824 825 /* our cp_error case, we can wait for any writeback page */ 826 f2fs_flush_merged_writes(sbi); 827 828 iput(sbi->node_inode); 829 iput(sbi->meta_inode); 830 831 /* destroy f2fs internal modules */ 832 destroy_node_manager(sbi); 833 destroy_segment_manager(sbi); 834 835 kfree(sbi->ckpt); 836 837 f2fs_unregister_sysfs(sbi); 838 839 sb->s_fs_info = NULL; 840 if (sbi->s_chksum_driver) 841 crypto_free_shash(sbi->s_chksum_driver); 842 kfree(sbi->raw_super); 843 844 destroy_device_list(sbi); 845 mempool_destroy(sbi->write_io_dummy); 846 #ifdef CONFIG_QUOTA 847 for (i = 0; i < MAXQUOTAS; i++) 848 kfree(sbi->s_qf_names[i]); 849 #endif 850 destroy_percpu_info(sbi); 851 for (i = 0; i < NR_PAGE_TYPE; i++) 852 kfree(sbi->write_io[i]); 853 kfree(sbi); 854 } 855 856 int f2fs_sync_fs(struct super_block *sb, int sync) 857 { 858 struct f2fs_sb_info *sbi = F2FS_SB(sb); 859 int err = 0; 860 861 trace_f2fs_sync_fs(sb, sync); 862 863 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING))) 864 return -EAGAIN; 865 866 if (sync) { 867 struct cp_control cpc; 868 869 cpc.reason = __get_cp_reason(sbi); 870 871 mutex_lock(&sbi->gc_mutex); 872 err = write_checkpoint(sbi, &cpc); 873 mutex_unlock(&sbi->gc_mutex); 874 } 875 f2fs_trace_ios(NULL, 1); 876 877 return err; 878 } 879 880 static int f2fs_freeze(struct super_block *sb) 881 { 882 if (f2fs_readonly(sb)) 883 return 0; 884 885 /* IO error happened before */ 886 if (unlikely(f2fs_cp_error(F2FS_SB(sb)))) 887 return -EIO; 888 889 /* must be clean, since sync_filesystem() was already called */ 890 if (is_sbi_flag_set(F2FS_SB(sb), SBI_IS_DIRTY)) 891 return -EINVAL; 892 return 0; 893 } 894 895 static int f2fs_unfreeze(struct super_block *sb) 896 { 897 return 0; 898 } 899 900 #ifdef CONFIG_QUOTA 901 static int f2fs_statfs_project(struct super_block *sb, 902 kprojid_t projid, struct kstatfs *buf) 903 { 904 struct kqid qid; 905 struct dquot *dquot; 906 u64 limit; 907 u64 curblock; 908 909 qid = make_kqid_projid(projid); 910 dquot = dqget(sb, qid); 911 if (IS_ERR(dquot)) 912 return PTR_ERR(dquot); 913 spin_lock(&dq_data_lock); 914 915 limit = (dquot->dq_dqb.dqb_bsoftlimit ? 916 dquot->dq_dqb.dqb_bsoftlimit : 917 dquot->dq_dqb.dqb_bhardlimit) >> sb->s_blocksize_bits; 918 if (limit && buf->f_blocks > limit) { 919 curblock = dquot->dq_dqb.dqb_curspace >> sb->s_blocksize_bits; 920 buf->f_blocks = limit; 921 buf->f_bfree = buf->f_bavail = 922 (buf->f_blocks > curblock) ? 923 (buf->f_blocks - curblock) : 0; 924 } 925 926 limit = dquot->dq_dqb.dqb_isoftlimit ? 927 dquot->dq_dqb.dqb_isoftlimit : 928 dquot->dq_dqb.dqb_ihardlimit; 929 if (limit && buf->f_files > limit) { 930 buf->f_files = limit; 931 buf->f_ffree = 932 (buf->f_files > dquot->dq_dqb.dqb_curinodes) ? 933 (buf->f_files - dquot->dq_dqb.dqb_curinodes) : 0; 934 } 935 936 spin_unlock(&dq_data_lock); 937 dqput(dquot); 938 return 0; 939 } 940 #endif 941 942 static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf) 943 { 944 struct super_block *sb = dentry->d_sb; 945 struct f2fs_sb_info *sbi = F2FS_SB(sb); 946 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 947 block_t total_count, user_block_count, start_count, ovp_count; 948 u64 avail_node_count; 949 950 total_count = le64_to_cpu(sbi->raw_super->block_count); 951 user_block_count = sbi->user_block_count; 952 start_count = le32_to_cpu(sbi->raw_super->segment0_blkaddr); 953 ovp_count = SM_I(sbi)->ovp_segments << sbi->log_blocks_per_seg; 954 buf->f_type = F2FS_SUPER_MAGIC; 955 buf->f_bsize = sbi->blocksize; 956 957 buf->f_blocks = total_count - start_count; 958 buf->f_bfree = user_block_count - valid_user_blocks(sbi) + ovp_count; 959 buf->f_bavail = user_block_count - valid_user_blocks(sbi) - 960 sbi->reserved_blocks; 961 962 avail_node_count = sbi->total_node_count - F2FS_RESERVED_NODE_NUM; 963 964 if (avail_node_count > user_block_count) { 965 buf->f_files = user_block_count; 966 buf->f_ffree = buf->f_bavail; 967 } else { 968 buf->f_files = avail_node_count; 969 buf->f_ffree = min(avail_node_count - valid_node_count(sbi), 970 buf->f_bavail); 971 } 972 973 buf->f_namelen = F2FS_NAME_LEN; 974 buf->f_fsid.val[0] = (u32)id; 975 buf->f_fsid.val[1] = (u32)(id >> 32); 976 977 #ifdef CONFIG_QUOTA 978 if (is_inode_flag_set(dentry->d_inode, FI_PROJ_INHERIT) && 979 sb_has_quota_limits_enabled(sb, PRJQUOTA)) { 980 f2fs_statfs_project(sb, F2FS_I(dentry->d_inode)->i_projid, buf); 981 } 982 #endif 983 return 0; 984 } 985 986 static inline void f2fs_show_quota_options(struct seq_file *seq, 987 struct super_block *sb) 988 { 989 #ifdef CONFIG_QUOTA 990 struct f2fs_sb_info *sbi = F2FS_SB(sb); 991 992 if (sbi->s_jquota_fmt) { 993 char *fmtname = ""; 994 995 switch (sbi->s_jquota_fmt) { 996 case QFMT_VFS_OLD: 997 fmtname = "vfsold"; 998 break; 999 case QFMT_VFS_V0: 1000 fmtname = "vfsv0"; 1001 break; 1002 case QFMT_VFS_V1: 1003 fmtname = "vfsv1"; 1004 break; 1005 } 1006 seq_printf(seq, ",jqfmt=%s", fmtname); 1007 } 1008 1009 if (sbi->s_qf_names[USRQUOTA]) 1010 seq_show_option(seq, "usrjquota", sbi->s_qf_names[USRQUOTA]); 1011 1012 if (sbi->s_qf_names[GRPQUOTA]) 1013 seq_show_option(seq, "grpjquota", sbi->s_qf_names[GRPQUOTA]); 1014 1015 if (sbi->s_qf_names[PRJQUOTA]) 1016 seq_show_option(seq, "prjjquota", sbi->s_qf_names[PRJQUOTA]); 1017 #endif 1018 } 1019 1020 static int f2fs_show_options(struct seq_file *seq, struct dentry *root) 1021 { 1022 struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb); 1023 1024 if (!f2fs_readonly(sbi->sb) && test_opt(sbi, BG_GC)) { 1025 if (test_opt(sbi, FORCE_FG_GC)) 1026 seq_printf(seq, ",background_gc=%s", "sync"); 1027 else 1028 seq_printf(seq, ",background_gc=%s", "on"); 1029 } else { 1030 seq_printf(seq, ",background_gc=%s", "off"); 1031 } 1032 if (test_opt(sbi, DISABLE_ROLL_FORWARD)) 1033 seq_puts(seq, ",disable_roll_forward"); 1034 if (test_opt(sbi, DISCARD)) 1035 seq_puts(seq, ",discard"); 1036 if (test_opt(sbi, NOHEAP)) 1037 seq_puts(seq, ",no_heap"); 1038 else 1039 seq_puts(seq, ",heap"); 1040 #ifdef CONFIG_F2FS_FS_XATTR 1041 if (test_opt(sbi, XATTR_USER)) 1042 seq_puts(seq, ",user_xattr"); 1043 else 1044 seq_puts(seq, ",nouser_xattr"); 1045 if (test_opt(sbi, INLINE_XATTR)) 1046 seq_puts(seq, ",inline_xattr"); 1047 else 1048 seq_puts(seq, ",noinline_xattr"); 1049 #endif 1050 #ifdef CONFIG_F2FS_FS_POSIX_ACL 1051 if (test_opt(sbi, POSIX_ACL)) 1052 seq_puts(seq, ",acl"); 1053 else 1054 seq_puts(seq, ",noacl"); 1055 #endif 1056 if (test_opt(sbi, DISABLE_EXT_IDENTIFY)) 1057 seq_puts(seq, ",disable_ext_identify"); 1058 if (test_opt(sbi, INLINE_DATA)) 1059 seq_puts(seq, ",inline_data"); 1060 else 1061 seq_puts(seq, ",noinline_data"); 1062 if (test_opt(sbi, INLINE_DENTRY)) 1063 seq_puts(seq, ",inline_dentry"); 1064 else 1065 seq_puts(seq, ",noinline_dentry"); 1066 if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE)) 1067 seq_puts(seq, ",flush_merge"); 1068 if (test_opt(sbi, NOBARRIER)) 1069 seq_puts(seq, ",nobarrier"); 1070 if (test_opt(sbi, FASTBOOT)) 1071 seq_puts(seq, ",fastboot"); 1072 if (test_opt(sbi, EXTENT_CACHE)) 1073 seq_puts(seq, ",extent_cache"); 1074 else 1075 seq_puts(seq, ",noextent_cache"); 1076 if (test_opt(sbi, DATA_FLUSH)) 1077 seq_puts(seq, ",data_flush"); 1078 1079 seq_puts(seq, ",mode="); 1080 if (test_opt(sbi, ADAPTIVE)) 1081 seq_puts(seq, "adaptive"); 1082 else if (test_opt(sbi, LFS)) 1083 seq_puts(seq, "lfs"); 1084 seq_printf(seq, ",active_logs=%u", sbi->active_logs); 1085 if (F2FS_IO_SIZE_BITS(sbi)) 1086 seq_printf(seq, ",io_size=%uKB", F2FS_IO_SIZE_KB(sbi)); 1087 #ifdef CONFIG_F2FS_FAULT_INJECTION 1088 if (test_opt(sbi, FAULT_INJECTION)) 1089 seq_printf(seq, ",fault_injection=%u", 1090 sbi->fault_info.inject_rate); 1091 #endif 1092 #ifdef CONFIG_QUOTA 1093 if (test_opt(sbi, QUOTA)) 1094 seq_puts(seq, ",quota"); 1095 if (test_opt(sbi, USRQUOTA)) 1096 seq_puts(seq, ",usrquota"); 1097 if (test_opt(sbi, GRPQUOTA)) 1098 seq_puts(seq, ",grpquota"); 1099 if (test_opt(sbi, PRJQUOTA)) 1100 seq_puts(seq, ",prjquota"); 1101 #endif 1102 f2fs_show_quota_options(seq, sbi->sb); 1103 1104 return 0; 1105 } 1106 1107 static void default_options(struct f2fs_sb_info *sbi) 1108 { 1109 /* init some FS parameters */ 1110 sbi->active_logs = NR_CURSEG_TYPE; 1111 1112 set_opt(sbi, BG_GC); 1113 set_opt(sbi, INLINE_XATTR); 1114 set_opt(sbi, INLINE_DATA); 1115 set_opt(sbi, INLINE_DENTRY); 1116 set_opt(sbi, EXTENT_CACHE); 1117 set_opt(sbi, NOHEAP); 1118 sbi->sb->s_flags |= MS_LAZYTIME; 1119 set_opt(sbi, FLUSH_MERGE); 1120 if (f2fs_sb_mounted_blkzoned(sbi->sb)) { 1121 set_opt_mode(sbi, F2FS_MOUNT_LFS); 1122 set_opt(sbi, DISCARD); 1123 } else { 1124 set_opt_mode(sbi, F2FS_MOUNT_ADAPTIVE); 1125 } 1126 1127 #ifdef CONFIG_F2FS_FS_XATTR 1128 set_opt(sbi, XATTR_USER); 1129 #endif 1130 #ifdef CONFIG_F2FS_FS_POSIX_ACL 1131 set_opt(sbi, POSIX_ACL); 1132 #endif 1133 1134 #ifdef CONFIG_F2FS_FAULT_INJECTION 1135 f2fs_build_fault_attr(sbi, 0); 1136 #endif 1137 } 1138 1139 static int f2fs_remount(struct super_block *sb, int *flags, char *data) 1140 { 1141 struct f2fs_sb_info *sbi = F2FS_SB(sb); 1142 struct f2fs_mount_info org_mount_opt; 1143 unsigned long old_sb_flags; 1144 int err, active_logs; 1145 bool need_restart_gc = false; 1146 bool need_stop_gc = false; 1147 bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE); 1148 #ifdef CONFIG_F2FS_FAULT_INJECTION 1149 struct f2fs_fault_info ffi = sbi->fault_info; 1150 #endif 1151 #ifdef CONFIG_QUOTA 1152 int s_jquota_fmt; 1153 char *s_qf_names[MAXQUOTAS]; 1154 int i, j; 1155 #endif 1156 1157 /* 1158 * Save the old mount options in case we 1159 * need to restore them. 1160 */ 1161 org_mount_opt = sbi->mount_opt; 1162 old_sb_flags = sb->s_flags; 1163 active_logs = sbi->active_logs; 1164 1165 #ifdef CONFIG_QUOTA 1166 s_jquota_fmt = sbi->s_jquota_fmt; 1167 for (i = 0; i < MAXQUOTAS; i++) { 1168 if (sbi->s_qf_names[i]) { 1169 s_qf_names[i] = kstrdup(sbi->s_qf_names[i], 1170 GFP_KERNEL); 1171 if (!s_qf_names[i]) { 1172 for (j = 0; j < i; j++) 1173 kfree(s_qf_names[j]); 1174 return -ENOMEM; 1175 } 1176 } else { 1177 s_qf_names[i] = NULL; 1178 } 1179 } 1180 #endif 1181 1182 /* recover superblocks we couldn't write due to previous RO mount */ 1183 if (!(*flags & MS_RDONLY) && is_sbi_flag_set(sbi, SBI_NEED_SB_WRITE)) { 1184 err = f2fs_commit_super(sbi, false); 1185 f2fs_msg(sb, KERN_INFO, 1186 "Try to recover all the superblocks, ret: %d", err); 1187 if (!err) 1188 clear_sbi_flag(sbi, SBI_NEED_SB_WRITE); 1189 } 1190 1191 default_options(sbi); 1192 1193 /* parse mount options */ 1194 err = parse_options(sb, data); 1195 if (err) 1196 goto restore_opts; 1197 1198 /* 1199 * Previous and new state of filesystem is RO, 1200 * so skip checking GC and FLUSH_MERGE conditions. 1201 */ 1202 if (f2fs_readonly(sb) && (*flags & MS_RDONLY)) 1203 goto skip; 1204 1205 if (!f2fs_readonly(sb) && (*flags & MS_RDONLY)) { 1206 err = dquot_suspend(sb, -1); 1207 if (err < 0) 1208 goto restore_opts; 1209 } else { 1210 /* dquot_resume needs RW */ 1211 sb->s_flags &= ~MS_RDONLY; 1212 dquot_resume(sb, -1); 1213 } 1214 1215 /* disallow enable/disable extent_cache dynamically */ 1216 if (no_extent_cache == !!test_opt(sbi, EXTENT_CACHE)) { 1217 err = -EINVAL; 1218 f2fs_msg(sbi->sb, KERN_WARNING, 1219 "switch extent_cache option is not allowed"); 1220 goto restore_opts; 1221 } 1222 1223 /* 1224 * We stop the GC thread if FS is mounted as RO 1225 * or if background_gc = off is passed in mount 1226 * option. Also sync the filesystem. 1227 */ 1228 if ((*flags & MS_RDONLY) || !test_opt(sbi, BG_GC)) { 1229 if (sbi->gc_thread) { 1230 stop_gc_thread(sbi); 1231 need_restart_gc = true; 1232 } 1233 } else if (!sbi->gc_thread) { 1234 err = start_gc_thread(sbi); 1235 if (err) 1236 goto restore_opts; 1237 need_stop_gc = true; 1238 } 1239 1240 if (*flags & MS_RDONLY) { 1241 writeback_inodes_sb(sb, WB_REASON_SYNC); 1242 sync_inodes_sb(sb); 1243 1244 set_sbi_flag(sbi, SBI_IS_DIRTY); 1245 set_sbi_flag(sbi, SBI_IS_CLOSE); 1246 f2fs_sync_fs(sb, 1); 1247 clear_sbi_flag(sbi, SBI_IS_CLOSE); 1248 } 1249 1250 /* 1251 * We stop issue flush thread if FS is mounted as RO 1252 * or if flush_merge is not passed in mount option. 1253 */ 1254 if ((*flags & MS_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) { 1255 clear_opt(sbi, FLUSH_MERGE); 1256 destroy_flush_cmd_control(sbi, false); 1257 } else { 1258 err = create_flush_cmd_control(sbi); 1259 if (err) 1260 goto restore_gc; 1261 } 1262 skip: 1263 #ifdef CONFIG_QUOTA 1264 /* Release old quota file names */ 1265 for (i = 0; i < MAXQUOTAS; i++) 1266 kfree(s_qf_names[i]); 1267 #endif 1268 /* Update the POSIXACL Flag */ 1269 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | 1270 (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0); 1271 1272 return 0; 1273 restore_gc: 1274 if (need_restart_gc) { 1275 if (start_gc_thread(sbi)) 1276 f2fs_msg(sbi->sb, KERN_WARNING, 1277 "background gc thread has stopped"); 1278 } else if (need_stop_gc) { 1279 stop_gc_thread(sbi); 1280 } 1281 restore_opts: 1282 #ifdef CONFIG_QUOTA 1283 sbi->s_jquota_fmt = s_jquota_fmt; 1284 for (i = 0; i < MAXQUOTAS; i++) { 1285 kfree(sbi->s_qf_names[i]); 1286 sbi->s_qf_names[i] = s_qf_names[i]; 1287 } 1288 #endif 1289 sbi->mount_opt = org_mount_opt; 1290 sbi->active_logs = active_logs; 1291 sb->s_flags = old_sb_flags; 1292 #ifdef CONFIG_F2FS_FAULT_INJECTION 1293 sbi->fault_info = ffi; 1294 #endif 1295 return err; 1296 } 1297 1298 #ifdef CONFIG_QUOTA 1299 /* Read data from quotafile */ 1300 static ssize_t f2fs_quota_read(struct super_block *sb, int type, char *data, 1301 size_t len, loff_t off) 1302 { 1303 struct inode *inode = sb_dqopt(sb)->files[type]; 1304 struct address_space *mapping = inode->i_mapping; 1305 block_t blkidx = F2FS_BYTES_TO_BLK(off); 1306 int offset = off & (sb->s_blocksize - 1); 1307 int tocopy; 1308 size_t toread; 1309 loff_t i_size = i_size_read(inode); 1310 struct page *page; 1311 char *kaddr; 1312 1313 if (off > i_size) 1314 return 0; 1315 1316 if (off + len > i_size) 1317 len = i_size - off; 1318 toread = len; 1319 while (toread > 0) { 1320 tocopy = min_t(unsigned long, sb->s_blocksize - offset, toread); 1321 repeat: 1322 page = read_mapping_page(mapping, blkidx, NULL); 1323 if (IS_ERR(page)) 1324 return PTR_ERR(page); 1325 1326 lock_page(page); 1327 1328 if (unlikely(page->mapping != mapping)) { 1329 f2fs_put_page(page, 1); 1330 goto repeat; 1331 } 1332 if (unlikely(!PageUptodate(page))) { 1333 f2fs_put_page(page, 1); 1334 return -EIO; 1335 } 1336 1337 kaddr = kmap_atomic(page); 1338 memcpy(data, kaddr + offset, tocopy); 1339 kunmap_atomic(kaddr); 1340 f2fs_put_page(page, 1); 1341 1342 offset = 0; 1343 toread -= tocopy; 1344 data += tocopy; 1345 blkidx++; 1346 } 1347 return len; 1348 } 1349 1350 /* Write to quotafile */ 1351 static ssize_t f2fs_quota_write(struct super_block *sb, int type, 1352 const char *data, size_t len, loff_t off) 1353 { 1354 struct inode *inode = sb_dqopt(sb)->files[type]; 1355 struct address_space *mapping = inode->i_mapping; 1356 const struct address_space_operations *a_ops = mapping->a_ops; 1357 int offset = off & (sb->s_blocksize - 1); 1358 size_t towrite = len; 1359 struct page *page; 1360 char *kaddr; 1361 int err = 0; 1362 int tocopy; 1363 1364 while (towrite > 0) { 1365 tocopy = min_t(unsigned long, sb->s_blocksize - offset, 1366 towrite); 1367 1368 err = a_ops->write_begin(NULL, mapping, off, tocopy, 0, 1369 &page, NULL); 1370 if (unlikely(err)) 1371 break; 1372 1373 kaddr = kmap_atomic(page); 1374 memcpy(kaddr + offset, data, tocopy); 1375 kunmap_atomic(kaddr); 1376 flush_dcache_page(page); 1377 1378 a_ops->write_end(NULL, mapping, off, tocopy, tocopy, 1379 page, NULL); 1380 offset = 0; 1381 towrite -= tocopy; 1382 off += tocopy; 1383 data += tocopy; 1384 cond_resched(); 1385 } 1386 1387 if (len == towrite) 1388 return 0; 1389 inode->i_version++; 1390 inode->i_mtime = inode->i_ctime = current_time(inode); 1391 f2fs_mark_inode_dirty_sync(inode, false); 1392 return len - towrite; 1393 } 1394 1395 static struct dquot **f2fs_get_dquots(struct inode *inode) 1396 { 1397 return F2FS_I(inode)->i_dquot; 1398 } 1399 1400 static qsize_t *f2fs_get_reserved_space(struct inode *inode) 1401 { 1402 return &F2FS_I(inode)->i_reserved_quota; 1403 } 1404 1405 static int f2fs_quota_on_mount(struct f2fs_sb_info *sbi, int type) 1406 { 1407 return dquot_quota_on_mount(sbi->sb, sbi->s_qf_names[type], 1408 sbi->s_jquota_fmt, type); 1409 } 1410 1411 void f2fs_enable_quota_files(struct f2fs_sb_info *sbi) 1412 { 1413 int i, ret; 1414 1415 for (i = 0; i < MAXQUOTAS; i++) { 1416 if (sbi->s_qf_names[i]) { 1417 ret = f2fs_quota_on_mount(sbi, i); 1418 if (ret < 0) 1419 f2fs_msg(sbi->sb, KERN_ERR, 1420 "Cannot turn on journaled " 1421 "quota: error %d", ret); 1422 } 1423 } 1424 } 1425 1426 static int f2fs_quota_sync(struct super_block *sb, int type) 1427 { 1428 struct quota_info *dqopt = sb_dqopt(sb); 1429 int cnt; 1430 int ret; 1431 1432 ret = dquot_writeback_dquots(sb, type); 1433 if (ret) 1434 return ret; 1435 1436 /* 1437 * Now when everything is written we can discard the pagecache so 1438 * that userspace sees the changes. 1439 */ 1440 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1441 if (type != -1 && cnt != type) 1442 continue; 1443 if (!sb_has_quota_active(sb, cnt)) 1444 continue; 1445 1446 ret = filemap_write_and_wait(dqopt->files[cnt]->i_mapping); 1447 if (ret) 1448 return ret; 1449 1450 inode_lock(dqopt->files[cnt]); 1451 truncate_inode_pages(&dqopt->files[cnt]->i_data, 0); 1452 inode_unlock(dqopt->files[cnt]); 1453 } 1454 return 0; 1455 } 1456 1457 static int f2fs_quota_on(struct super_block *sb, int type, int format_id, 1458 const struct path *path) 1459 { 1460 struct inode *inode; 1461 int err; 1462 1463 err = f2fs_quota_sync(sb, type); 1464 if (err) 1465 return err; 1466 1467 err = dquot_quota_on(sb, type, format_id, path); 1468 if (err) 1469 return err; 1470 1471 inode = d_inode(path->dentry); 1472 1473 inode_lock(inode); 1474 F2FS_I(inode)->i_flags |= FS_NOATIME_FL | FS_IMMUTABLE_FL; 1475 inode_set_flags(inode, S_NOATIME | S_IMMUTABLE, 1476 S_NOATIME | S_IMMUTABLE); 1477 inode_unlock(inode); 1478 f2fs_mark_inode_dirty_sync(inode, false); 1479 1480 return 0; 1481 } 1482 1483 static int f2fs_quota_off(struct super_block *sb, int type) 1484 { 1485 struct inode *inode = sb_dqopt(sb)->files[type]; 1486 int err; 1487 1488 if (!inode || !igrab(inode)) 1489 return dquot_quota_off(sb, type); 1490 1491 f2fs_quota_sync(sb, type); 1492 1493 err = dquot_quota_off(sb, type); 1494 if (err) 1495 goto out_put; 1496 1497 inode_lock(inode); 1498 F2FS_I(inode)->i_flags &= ~(FS_NOATIME_FL | FS_IMMUTABLE_FL); 1499 inode_set_flags(inode, 0, S_NOATIME | S_IMMUTABLE); 1500 inode_unlock(inode); 1501 f2fs_mark_inode_dirty_sync(inode, false); 1502 out_put: 1503 iput(inode); 1504 return err; 1505 } 1506 1507 void f2fs_quota_off_umount(struct super_block *sb) 1508 { 1509 int type; 1510 1511 for (type = 0; type < MAXQUOTAS; type++) 1512 f2fs_quota_off(sb, type); 1513 } 1514 1515 int f2fs_get_projid(struct inode *inode, kprojid_t *projid) 1516 { 1517 *projid = F2FS_I(inode)->i_projid; 1518 return 0; 1519 } 1520 1521 static const struct dquot_operations f2fs_quota_operations = { 1522 .get_reserved_space = f2fs_get_reserved_space, 1523 .write_dquot = dquot_commit, 1524 .acquire_dquot = dquot_acquire, 1525 .release_dquot = dquot_release, 1526 .mark_dirty = dquot_mark_dquot_dirty, 1527 .write_info = dquot_commit_info, 1528 .alloc_dquot = dquot_alloc, 1529 .destroy_dquot = dquot_destroy, 1530 .get_projid = f2fs_get_projid, 1531 .get_next_id = dquot_get_next_id, 1532 }; 1533 1534 static const struct quotactl_ops f2fs_quotactl_ops = { 1535 .quota_on = f2fs_quota_on, 1536 .quota_off = f2fs_quota_off, 1537 .quota_sync = f2fs_quota_sync, 1538 .get_state = dquot_get_state, 1539 .set_info = dquot_set_dqinfo, 1540 .get_dqblk = dquot_get_dqblk, 1541 .set_dqblk = dquot_set_dqblk, 1542 .get_nextdqblk = dquot_get_next_dqblk, 1543 }; 1544 #else 1545 void f2fs_quota_off_umount(struct super_block *sb) 1546 { 1547 } 1548 #endif 1549 1550 static const struct super_operations f2fs_sops = { 1551 .alloc_inode = f2fs_alloc_inode, 1552 .drop_inode = f2fs_drop_inode, 1553 .destroy_inode = f2fs_destroy_inode, 1554 .write_inode = f2fs_write_inode, 1555 .dirty_inode = f2fs_dirty_inode, 1556 .show_options = f2fs_show_options, 1557 #ifdef CONFIG_QUOTA 1558 .quota_read = f2fs_quota_read, 1559 .quota_write = f2fs_quota_write, 1560 .get_dquots = f2fs_get_dquots, 1561 #endif 1562 .evict_inode = f2fs_evict_inode, 1563 .put_super = f2fs_put_super, 1564 .sync_fs = f2fs_sync_fs, 1565 .freeze_fs = f2fs_freeze, 1566 .unfreeze_fs = f2fs_unfreeze, 1567 .statfs = f2fs_statfs, 1568 .remount_fs = f2fs_remount, 1569 }; 1570 1571 #ifdef CONFIG_F2FS_FS_ENCRYPTION 1572 static int f2fs_get_context(struct inode *inode, void *ctx, size_t len) 1573 { 1574 return f2fs_getxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION, 1575 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT, 1576 ctx, len, NULL); 1577 } 1578 1579 static int f2fs_set_context(struct inode *inode, const void *ctx, size_t len, 1580 void *fs_data) 1581 { 1582 return f2fs_setxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION, 1583 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT, 1584 ctx, len, fs_data, XATTR_CREATE); 1585 } 1586 1587 static unsigned f2fs_max_namelen(struct inode *inode) 1588 { 1589 return S_ISLNK(inode->i_mode) ? 1590 inode->i_sb->s_blocksize : F2FS_NAME_LEN; 1591 } 1592 1593 static const struct fscrypt_operations f2fs_cryptops = { 1594 .key_prefix = "f2fs:", 1595 .get_context = f2fs_get_context, 1596 .set_context = f2fs_set_context, 1597 .empty_dir = f2fs_empty_dir, 1598 .max_namelen = f2fs_max_namelen, 1599 }; 1600 #endif 1601 1602 static struct inode *f2fs_nfs_get_inode(struct super_block *sb, 1603 u64 ino, u32 generation) 1604 { 1605 struct f2fs_sb_info *sbi = F2FS_SB(sb); 1606 struct inode *inode; 1607 1608 if (check_nid_range(sbi, ino)) 1609 return ERR_PTR(-ESTALE); 1610 1611 /* 1612 * f2fs_iget isn't quite right if the inode is currently unallocated! 1613 * However f2fs_iget currently does appropriate checks to handle stale 1614 * inodes so everything is OK. 1615 */ 1616 inode = f2fs_iget(sb, ino); 1617 if (IS_ERR(inode)) 1618 return ERR_CAST(inode); 1619 if (unlikely(generation && inode->i_generation != generation)) { 1620 /* we didn't find the right inode.. */ 1621 iput(inode); 1622 return ERR_PTR(-ESTALE); 1623 } 1624 return inode; 1625 } 1626 1627 static struct dentry *f2fs_fh_to_dentry(struct super_block *sb, struct fid *fid, 1628 int fh_len, int fh_type) 1629 { 1630 return generic_fh_to_dentry(sb, fid, fh_len, fh_type, 1631 f2fs_nfs_get_inode); 1632 } 1633 1634 static struct dentry *f2fs_fh_to_parent(struct super_block *sb, struct fid *fid, 1635 int fh_len, int fh_type) 1636 { 1637 return generic_fh_to_parent(sb, fid, fh_len, fh_type, 1638 f2fs_nfs_get_inode); 1639 } 1640 1641 static const struct export_operations f2fs_export_ops = { 1642 .fh_to_dentry = f2fs_fh_to_dentry, 1643 .fh_to_parent = f2fs_fh_to_parent, 1644 .get_parent = f2fs_get_parent, 1645 }; 1646 1647 static loff_t max_file_blocks(void) 1648 { 1649 loff_t result = 0; 1650 loff_t leaf_count = ADDRS_PER_BLOCK; 1651 1652 /* 1653 * note: previously, result is equal to (DEF_ADDRS_PER_INODE - 1654 * F2FS_INLINE_XATTR_ADDRS), but now f2fs try to reserve more 1655 * space in inode.i_addr, it will be more safe to reassign 1656 * result as zero. 1657 */ 1658 1659 /* two direct node blocks */ 1660 result += (leaf_count * 2); 1661 1662 /* two indirect node blocks */ 1663 leaf_count *= NIDS_PER_BLOCK; 1664 result += (leaf_count * 2); 1665 1666 /* one double indirect node block */ 1667 leaf_count *= NIDS_PER_BLOCK; 1668 result += leaf_count; 1669 1670 return result; 1671 } 1672 1673 static int __f2fs_commit_super(struct buffer_head *bh, 1674 struct f2fs_super_block *super) 1675 { 1676 lock_buffer(bh); 1677 if (super) 1678 memcpy(bh->b_data + F2FS_SUPER_OFFSET, super, sizeof(*super)); 1679 set_buffer_uptodate(bh); 1680 set_buffer_dirty(bh); 1681 unlock_buffer(bh); 1682 1683 /* it's rare case, we can do fua all the time */ 1684 return __sync_dirty_buffer(bh, REQ_SYNC | REQ_PREFLUSH | REQ_FUA); 1685 } 1686 1687 static inline bool sanity_check_area_boundary(struct f2fs_sb_info *sbi, 1688 struct buffer_head *bh) 1689 { 1690 struct f2fs_super_block *raw_super = (struct f2fs_super_block *) 1691 (bh->b_data + F2FS_SUPER_OFFSET); 1692 struct super_block *sb = sbi->sb; 1693 u32 segment0_blkaddr = le32_to_cpu(raw_super->segment0_blkaddr); 1694 u32 cp_blkaddr = le32_to_cpu(raw_super->cp_blkaddr); 1695 u32 sit_blkaddr = le32_to_cpu(raw_super->sit_blkaddr); 1696 u32 nat_blkaddr = le32_to_cpu(raw_super->nat_blkaddr); 1697 u32 ssa_blkaddr = le32_to_cpu(raw_super->ssa_blkaddr); 1698 u32 main_blkaddr = le32_to_cpu(raw_super->main_blkaddr); 1699 u32 segment_count_ckpt = le32_to_cpu(raw_super->segment_count_ckpt); 1700 u32 segment_count_sit = le32_to_cpu(raw_super->segment_count_sit); 1701 u32 segment_count_nat = le32_to_cpu(raw_super->segment_count_nat); 1702 u32 segment_count_ssa = le32_to_cpu(raw_super->segment_count_ssa); 1703 u32 segment_count_main = le32_to_cpu(raw_super->segment_count_main); 1704 u32 segment_count = le32_to_cpu(raw_super->segment_count); 1705 u32 log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg); 1706 u64 main_end_blkaddr = main_blkaddr + 1707 (segment_count_main << log_blocks_per_seg); 1708 u64 seg_end_blkaddr = segment0_blkaddr + 1709 (segment_count << log_blocks_per_seg); 1710 1711 if (segment0_blkaddr != cp_blkaddr) { 1712 f2fs_msg(sb, KERN_INFO, 1713 "Mismatch start address, segment0(%u) cp_blkaddr(%u)", 1714 segment0_blkaddr, cp_blkaddr); 1715 return true; 1716 } 1717 1718 if (cp_blkaddr + (segment_count_ckpt << log_blocks_per_seg) != 1719 sit_blkaddr) { 1720 f2fs_msg(sb, KERN_INFO, 1721 "Wrong CP boundary, start(%u) end(%u) blocks(%u)", 1722 cp_blkaddr, sit_blkaddr, 1723 segment_count_ckpt << log_blocks_per_seg); 1724 return true; 1725 } 1726 1727 if (sit_blkaddr + (segment_count_sit << log_blocks_per_seg) != 1728 nat_blkaddr) { 1729 f2fs_msg(sb, KERN_INFO, 1730 "Wrong SIT boundary, start(%u) end(%u) blocks(%u)", 1731 sit_blkaddr, nat_blkaddr, 1732 segment_count_sit << log_blocks_per_seg); 1733 return true; 1734 } 1735 1736 if (nat_blkaddr + (segment_count_nat << log_blocks_per_seg) != 1737 ssa_blkaddr) { 1738 f2fs_msg(sb, KERN_INFO, 1739 "Wrong NAT boundary, start(%u) end(%u) blocks(%u)", 1740 nat_blkaddr, ssa_blkaddr, 1741 segment_count_nat << log_blocks_per_seg); 1742 return true; 1743 } 1744 1745 if (ssa_blkaddr + (segment_count_ssa << log_blocks_per_seg) != 1746 main_blkaddr) { 1747 f2fs_msg(sb, KERN_INFO, 1748 "Wrong SSA boundary, start(%u) end(%u) blocks(%u)", 1749 ssa_blkaddr, main_blkaddr, 1750 segment_count_ssa << log_blocks_per_seg); 1751 return true; 1752 } 1753 1754 if (main_end_blkaddr > seg_end_blkaddr) { 1755 f2fs_msg(sb, KERN_INFO, 1756 "Wrong MAIN_AREA boundary, start(%u) end(%u) block(%u)", 1757 main_blkaddr, 1758 segment0_blkaddr + 1759 (segment_count << log_blocks_per_seg), 1760 segment_count_main << log_blocks_per_seg); 1761 return true; 1762 } else if (main_end_blkaddr < seg_end_blkaddr) { 1763 int err = 0; 1764 char *res; 1765 1766 /* fix in-memory information all the time */ 1767 raw_super->segment_count = cpu_to_le32((main_end_blkaddr - 1768 segment0_blkaddr) >> log_blocks_per_seg); 1769 1770 if (f2fs_readonly(sb) || bdev_read_only(sb->s_bdev)) { 1771 set_sbi_flag(sbi, SBI_NEED_SB_WRITE); 1772 res = "internally"; 1773 } else { 1774 err = __f2fs_commit_super(bh, NULL); 1775 res = err ? "failed" : "done"; 1776 } 1777 f2fs_msg(sb, KERN_INFO, 1778 "Fix alignment : %s, start(%u) end(%u) block(%u)", 1779 res, main_blkaddr, 1780 segment0_blkaddr + 1781 (segment_count << log_blocks_per_seg), 1782 segment_count_main << log_blocks_per_seg); 1783 if (err) 1784 return true; 1785 } 1786 return false; 1787 } 1788 1789 static int sanity_check_raw_super(struct f2fs_sb_info *sbi, 1790 struct buffer_head *bh) 1791 { 1792 struct f2fs_super_block *raw_super = (struct f2fs_super_block *) 1793 (bh->b_data + F2FS_SUPER_OFFSET); 1794 struct super_block *sb = sbi->sb; 1795 unsigned int blocksize; 1796 1797 if (F2FS_SUPER_MAGIC != le32_to_cpu(raw_super->magic)) { 1798 f2fs_msg(sb, KERN_INFO, 1799 "Magic Mismatch, valid(0x%x) - read(0x%x)", 1800 F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic)); 1801 return 1; 1802 } 1803 1804 /* Currently, support only 4KB page cache size */ 1805 if (F2FS_BLKSIZE != PAGE_SIZE) { 1806 f2fs_msg(sb, KERN_INFO, 1807 "Invalid page_cache_size (%lu), supports only 4KB\n", 1808 PAGE_SIZE); 1809 return 1; 1810 } 1811 1812 /* Currently, support only 4KB block size */ 1813 blocksize = 1 << le32_to_cpu(raw_super->log_blocksize); 1814 if (blocksize != F2FS_BLKSIZE) { 1815 f2fs_msg(sb, KERN_INFO, 1816 "Invalid blocksize (%u), supports only 4KB\n", 1817 blocksize); 1818 return 1; 1819 } 1820 1821 /* check log blocks per segment */ 1822 if (le32_to_cpu(raw_super->log_blocks_per_seg) != 9) { 1823 f2fs_msg(sb, KERN_INFO, 1824 "Invalid log blocks per segment (%u)\n", 1825 le32_to_cpu(raw_super->log_blocks_per_seg)); 1826 return 1; 1827 } 1828 1829 /* Currently, support 512/1024/2048/4096 bytes sector size */ 1830 if (le32_to_cpu(raw_super->log_sectorsize) > 1831 F2FS_MAX_LOG_SECTOR_SIZE || 1832 le32_to_cpu(raw_super->log_sectorsize) < 1833 F2FS_MIN_LOG_SECTOR_SIZE) { 1834 f2fs_msg(sb, KERN_INFO, "Invalid log sectorsize (%u)", 1835 le32_to_cpu(raw_super->log_sectorsize)); 1836 return 1; 1837 } 1838 if (le32_to_cpu(raw_super->log_sectors_per_block) + 1839 le32_to_cpu(raw_super->log_sectorsize) != 1840 F2FS_MAX_LOG_SECTOR_SIZE) { 1841 f2fs_msg(sb, KERN_INFO, 1842 "Invalid log sectors per block(%u) log sectorsize(%u)", 1843 le32_to_cpu(raw_super->log_sectors_per_block), 1844 le32_to_cpu(raw_super->log_sectorsize)); 1845 return 1; 1846 } 1847 1848 /* check reserved ino info */ 1849 if (le32_to_cpu(raw_super->node_ino) != 1 || 1850 le32_to_cpu(raw_super->meta_ino) != 2 || 1851 le32_to_cpu(raw_super->root_ino) != 3) { 1852 f2fs_msg(sb, KERN_INFO, 1853 "Invalid Fs Meta Ino: node(%u) meta(%u) root(%u)", 1854 le32_to_cpu(raw_super->node_ino), 1855 le32_to_cpu(raw_super->meta_ino), 1856 le32_to_cpu(raw_super->root_ino)); 1857 return 1; 1858 } 1859 1860 if (le32_to_cpu(raw_super->segment_count) > F2FS_MAX_SEGMENT) { 1861 f2fs_msg(sb, KERN_INFO, 1862 "Invalid segment count (%u)", 1863 le32_to_cpu(raw_super->segment_count)); 1864 return 1; 1865 } 1866 1867 /* check CP/SIT/NAT/SSA/MAIN_AREA area boundary */ 1868 if (sanity_check_area_boundary(sbi, bh)) 1869 return 1; 1870 1871 return 0; 1872 } 1873 1874 int sanity_check_ckpt(struct f2fs_sb_info *sbi) 1875 { 1876 unsigned int total, fsmeta; 1877 struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi); 1878 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 1879 unsigned int ovp_segments, reserved_segments; 1880 unsigned int main_segs, blocks_per_seg; 1881 int i; 1882 1883 total = le32_to_cpu(raw_super->segment_count); 1884 fsmeta = le32_to_cpu(raw_super->segment_count_ckpt); 1885 fsmeta += le32_to_cpu(raw_super->segment_count_sit); 1886 fsmeta += le32_to_cpu(raw_super->segment_count_nat); 1887 fsmeta += le32_to_cpu(ckpt->rsvd_segment_count); 1888 fsmeta += le32_to_cpu(raw_super->segment_count_ssa); 1889 1890 if (unlikely(fsmeta >= total)) 1891 return 1; 1892 1893 ovp_segments = le32_to_cpu(ckpt->overprov_segment_count); 1894 reserved_segments = le32_to_cpu(ckpt->rsvd_segment_count); 1895 1896 if (unlikely(fsmeta < F2FS_MIN_SEGMENTS || 1897 ovp_segments == 0 || reserved_segments == 0)) { 1898 f2fs_msg(sbi->sb, KERN_ERR, 1899 "Wrong layout: check mkfs.f2fs version"); 1900 return 1; 1901 } 1902 1903 main_segs = le32_to_cpu(raw_super->segment_count_main); 1904 blocks_per_seg = sbi->blocks_per_seg; 1905 1906 for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) { 1907 if (le32_to_cpu(ckpt->cur_node_segno[i]) >= main_segs || 1908 le16_to_cpu(ckpt->cur_node_blkoff[i]) >= blocks_per_seg) 1909 return 1; 1910 } 1911 for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) { 1912 if (le32_to_cpu(ckpt->cur_data_segno[i]) >= main_segs || 1913 le16_to_cpu(ckpt->cur_data_blkoff[i]) >= blocks_per_seg) 1914 return 1; 1915 } 1916 1917 if (unlikely(f2fs_cp_error(sbi))) { 1918 f2fs_msg(sbi->sb, KERN_ERR, "A bug case: need to run fsck"); 1919 return 1; 1920 } 1921 return 0; 1922 } 1923 1924 static void init_sb_info(struct f2fs_sb_info *sbi) 1925 { 1926 struct f2fs_super_block *raw_super = sbi->raw_super; 1927 int i, j; 1928 1929 sbi->log_sectors_per_block = 1930 le32_to_cpu(raw_super->log_sectors_per_block); 1931 sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize); 1932 sbi->blocksize = 1 << sbi->log_blocksize; 1933 sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg); 1934 sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg; 1935 sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec); 1936 sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone); 1937 sbi->total_sections = le32_to_cpu(raw_super->section_count); 1938 sbi->total_node_count = 1939 (le32_to_cpu(raw_super->segment_count_nat) / 2) 1940 * sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK; 1941 sbi->root_ino_num = le32_to_cpu(raw_super->root_ino); 1942 sbi->node_ino_num = le32_to_cpu(raw_super->node_ino); 1943 sbi->meta_ino_num = le32_to_cpu(raw_super->meta_ino); 1944 sbi->cur_victim_sec = NULL_SECNO; 1945 sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH; 1946 1947 sbi->dir_level = DEF_DIR_LEVEL; 1948 sbi->interval_time[CP_TIME] = DEF_CP_INTERVAL; 1949 sbi->interval_time[REQ_TIME] = DEF_IDLE_INTERVAL; 1950 clear_sbi_flag(sbi, SBI_NEED_FSCK); 1951 1952 for (i = 0; i < NR_COUNT_TYPE; i++) 1953 atomic_set(&sbi->nr_pages[i], 0); 1954 1955 atomic_set(&sbi->wb_sync_req, 0); 1956 1957 INIT_LIST_HEAD(&sbi->s_list); 1958 mutex_init(&sbi->umount_mutex); 1959 for (i = 0; i < NR_PAGE_TYPE - 1; i++) 1960 for (j = HOT; j < NR_TEMP_TYPE; j++) 1961 mutex_init(&sbi->wio_mutex[i][j]); 1962 spin_lock_init(&sbi->cp_lock); 1963 } 1964 1965 static int init_percpu_info(struct f2fs_sb_info *sbi) 1966 { 1967 int err; 1968 1969 err = percpu_counter_init(&sbi->alloc_valid_block_count, 0, GFP_KERNEL); 1970 if (err) 1971 return err; 1972 1973 return percpu_counter_init(&sbi->total_valid_inode_count, 0, 1974 GFP_KERNEL); 1975 } 1976 1977 #ifdef CONFIG_BLK_DEV_ZONED 1978 static int init_blkz_info(struct f2fs_sb_info *sbi, int devi) 1979 { 1980 struct block_device *bdev = FDEV(devi).bdev; 1981 sector_t nr_sectors = bdev->bd_part->nr_sects; 1982 sector_t sector = 0; 1983 struct blk_zone *zones; 1984 unsigned int i, nr_zones; 1985 unsigned int n = 0; 1986 int err = -EIO; 1987 1988 if (!f2fs_sb_mounted_blkzoned(sbi->sb)) 1989 return 0; 1990 1991 if (sbi->blocks_per_blkz && sbi->blocks_per_blkz != 1992 SECTOR_TO_BLOCK(bdev_zone_sectors(bdev))) 1993 return -EINVAL; 1994 sbi->blocks_per_blkz = SECTOR_TO_BLOCK(bdev_zone_sectors(bdev)); 1995 if (sbi->log_blocks_per_blkz && sbi->log_blocks_per_blkz != 1996 __ilog2_u32(sbi->blocks_per_blkz)) 1997 return -EINVAL; 1998 sbi->log_blocks_per_blkz = __ilog2_u32(sbi->blocks_per_blkz); 1999 FDEV(devi).nr_blkz = SECTOR_TO_BLOCK(nr_sectors) >> 2000 sbi->log_blocks_per_blkz; 2001 if (nr_sectors & (bdev_zone_sectors(bdev) - 1)) 2002 FDEV(devi).nr_blkz++; 2003 2004 FDEV(devi).blkz_type = kmalloc(FDEV(devi).nr_blkz, GFP_KERNEL); 2005 if (!FDEV(devi).blkz_type) 2006 return -ENOMEM; 2007 2008 #define F2FS_REPORT_NR_ZONES 4096 2009 2010 zones = kcalloc(F2FS_REPORT_NR_ZONES, sizeof(struct blk_zone), 2011 GFP_KERNEL); 2012 if (!zones) 2013 return -ENOMEM; 2014 2015 /* Get block zones type */ 2016 while (zones && sector < nr_sectors) { 2017 2018 nr_zones = F2FS_REPORT_NR_ZONES; 2019 err = blkdev_report_zones(bdev, sector, 2020 zones, &nr_zones, 2021 GFP_KERNEL); 2022 if (err) 2023 break; 2024 if (!nr_zones) { 2025 err = -EIO; 2026 break; 2027 } 2028 2029 for (i = 0; i < nr_zones; i++) { 2030 FDEV(devi).blkz_type[n] = zones[i].type; 2031 sector += zones[i].len; 2032 n++; 2033 } 2034 } 2035 2036 kfree(zones); 2037 2038 return err; 2039 } 2040 #endif 2041 2042 /* 2043 * Read f2fs raw super block. 2044 * Because we have two copies of super block, so read both of them 2045 * to get the first valid one. If any one of them is broken, we pass 2046 * them recovery flag back to the caller. 2047 */ 2048 static int read_raw_super_block(struct f2fs_sb_info *sbi, 2049 struct f2fs_super_block **raw_super, 2050 int *valid_super_block, int *recovery) 2051 { 2052 struct super_block *sb = sbi->sb; 2053 int block; 2054 struct buffer_head *bh; 2055 struct f2fs_super_block *super; 2056 int err = 0; 2057 2058 super = kzalloc(sizeof(struct f2fs_super_block), GFP_KERNEL); 2059 if (!super) 2060 return -ENOMEM; 2061 2062 for (block = 0; block < 2; block++) { 2063 bh = sb_bread(sb, block); 2064 if (!bh) { 2065 f2fs_msg(sb, KERN_ERR, "Unable to read %dth superblock", 2066 block + 1); 2067 err = -EIO; 2068 continue; 2069 } 2070 2071 /* sanity checking of raw super */ 2072 if (sanity_check_raw_super(sbi, bh)) { 2073 f2fs_msg(sb, KERN_ERR, 2074 "Can't find valid F2FS filesystem in %dth superblock", 2075 block + 1); 2076 err = -EINVAL; 2077 brelse(bh); 2078 continue; 2079 } 2080 2081 if (!*raw_super) { 2082 memcpy(super, bh->b_data + F2FS_SUPER_OFFSET, 2083 sizeof(*super)); 2084 *valid_super_block = block; 2085 *raw_super = super; 2086 } 2087 brelse(bh); 2088 } 2089 2090 /* Fail to read any one of the superblocks*/ 2091 if (err < 0) 2092 *recovery = 1; 2093 2094 /* No valid superblock */ 2095 if (!*raw_super) 2096 kfree(super); 2097 else 2098 err = 0; 2099 2100 return err; 2101 } 2102 2103 int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover) 2104 { 2105 struct buffer_head *bh; 2106 int err; 2107 2108 if ((recover && f2fs_readonly(sbi->sb)) || 2109 bdev_read_only(sbi->sb->s_bdev)) { 2110 set_sbi_flag(sbi, SBI_NEED_SB_WRITE); 2111 return -EROFS; 2112 } 2113 2114 /* write back-up superblock first */ 2115 bh = sb_getblk(sbi->sb, sbi->valid_super_block ? 0: 1); 2116 if (!bh) 2117 return -EIO; 2118 err = __f2fs_commit_super(bh, F2FS_RAW_SUPER(sbi)); 2119 brelse(bh); 2120 2121 /* if we are in recovery path, skip writing valid superblock */ 2122 if (recover || err) 2123 return err; 2124 2125 /* write current valid superblock */ 2126 bh = sb_getblk(sbi->sb, sbi->valid_super_block); 2127 if (!bh) 2128 return -EIO; 2129 err = __f2fs_commit_super(bh, F2FS_RAW_SUPER(sbi)); 2130 brelse(bh); 2131 return err; 2132 } 2133 2134 static int f2fs_scan_devices(struct f2fs_sb_info *sbi) 2135 { 2136 struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi); 2137 unsigned int max_devices = MAX_DEVICES; 2138 int i; 2139 2140 /* Initialize single device information */ 2141 if (!RDEV(0).path[0]) { 2142 if (!bdev_is_zoned(sbi->sb->s_bdev)) 2143 return 0; 2144 max_devices = 1; 2145 } 2146 2147 /* 2148 * Initialize multiple devices information, or single 2149 * zoned block device information. 2150 */ 2151 sbi->devs = kcalloc(max_devices, sizeof(struct f2fs_dev_info), 2152 GFP_KERNEL); 2153 if (!sbi->devs) 2154 return -ENOMEM; 2155 2156 for (i = 0; i < max_devices; i++) { 2157 2158 if (i > 0 && !RDEV(i).path[0]) 2159 break; 2160 2161 if (max_devices == 1) { 2162 /* Single zoned block device mount */ 2163 FDEV(0).bdev = 2164 blkdev_get_by_dev(sbi->sb->s_bdev->bd_dev, 2165 sbi->sb->s_mode, sbi->sb->s_type); 2166 } else { 2167 /* Multi-device mount */ 2168 memcpy(FDEV(i).path, RDEV(i).path, MAX_PATH_LEN); 2169 FDEV(i).total_segments = 2170 le32_to_cpu(RDEV(i).total_segments); 2171 if (i == 0) { 2172 FDEV(i).start_blk = 0; 2173 FDEV(i).end_blk = FDEV(i).start_blk + 2174 (FDEV(i).total_segments << 2175 sbi->log_blocks_per_seg) - 1 + 2176 le32_to_cpu(raw_super->segment0_blkaddr); 2177 } else { 2178 FDEV(i).start_blk = FDEV(i - 1).end_blk + 1; 2179 FDEV(i).end_blk = FDEV(i).start_blk + 2180 (FDEV(i).total_segments << 2181 sbi->log_blocks_per_seg) - 1; 2182 } 2183 FDEV(i).bdev = blkdev_get_by_path(FDEV(i).path, 2184 sbi->sb->s_mode, sbi->sb->s_type); 2185 } 2186 if (IS_ERR(FDEV(i).bdev)) 2187 return PTR_ERR(FDEV(i).bdev); 2188 2189 /* to release errored devices */ 2190 sbi->s_ndevs = i + 1; 2191 2192 #ifdef CONFIG_BLK_DEV_ZONED 2193 if (bdev_zoned_model(FDEV(i).bdev) == BLK_ZONED_HM && 2194 !f2fs_sb_mounted_blkzoned(sbi->sb)) { 2195 f2fs_msg(sbi->sb, KERN_ERR, 2196 "Zoned block device feature not enabled\n"); 2197 return -EINVAL; 2198 } 2199 if (bdev_zoned_model(FDEV(i).bdev) != BLK_ZONED_NONE) { 2200 if (init_blkz_info(sbi, i)) { 2201 f2fs_msg(sbi->sb, KERN_ERR, 2202 "Failed to initialize F2FS blkzone information"); 2203 return -EINVAL; 2204 } 2205 if (max_devices == 1) 2206 break; 2207 f2fs_msg(sbi->sb, KERN_INFO, 2208 "Mount Device [%2d]: %20s, %8u, %8x - %8x (zone: %s)", 2209 i, FDEV(i).path, 2210 FDEV(i).total_segments, 2211 FDEV(i).start_blk, FDEV(i).end_blk, 2212 bdev_zoned_model(FDEV(i).bdev) == BLK_ZONED_HA ? 2213 "Host-aware" : "Host-managed"); 2214 continue; 2215 } 2216 #endif 2217 f2fs_msg(sbi->sb, KERN_INFO, 2218 "Mount Device [%2d]: %20s, %8u, %8x - %8x", 2219 i, FDEV(i).path, 2220 FDEV(i).total_segments, 2221 FDEV(i).start_blk, FDEV(i).end_blk); 2222 } 2223 f2fs_msg(sbi->sb, KERN_INFO, 2224 "IO Block Size: %8d KB", F2FS_IO_SIZE_KB(sbi)); 2225 return 0; 2226 } 2227 2228 static int f2fs_fill_super(struct super_block *sb, void *data, int silent) 2229 { 2230 struct f2fs_sb_info *sbi; 2231 struct f2fs_super_block *raw_super; 2232 struct inode *root; 2233 int err; 2234 bool retry = true, need_fsck = false; 2235 char *options = NULL; 2236 int recovery, i, valid_super_block; 2237 struct curseg_info *seg_i; 2238 2239 try_onemore: 2240 err = -EINVAL; 2241 raw_super = NULL; 2242 valid_super_block = -1; 2243 recovery = 0; 2244 2245 /* allocate memory for f2fs-specific super block info */ 2246 sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL); 2247 if (!sbi) 2248 return -ENOMEM; 2249 2250 sbi->sb = sb; 2251 2252 /* Load the checksum driver */ 2253 sbi->s_chksum_driver = crypto_alloc_shash("crc32", 0, 0); 2254 if (IS_ERR(sbi->s_chksum_driver)) { 2255 f2fs_msg(sb, KERN_ERR, "Cannot load crc32 driver."); 2256 err = PTR_ERR(sbi->s_chksum_driver); 2257 sbi->s_chksum_driver = NULL; 2258 goto free_sbi; 2259 } 2260 2261 /* set a block size */ 2262 if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) { 2263 f2fs_msg(sb, KERN_ERR, "unable to set blocksize"); 2264 goto free_sbi; 2265 } 2266 2267 err = read_raw_super_block(sbi, &raw_super, &valid_super_block, 2268 &recovery); 2269 if (err) 2270 goto free_sbi; 2271 2272 sb->s_fs_info = sbi; 2273 sbi->raw_super = raw_super; 2274 2275 /* precompute checksum seed for metadata */ 2276 if (f2fs_sb_has_inode_chksum(sb)) 2277 sbi->s_chksum_seed = f2fs_chksum(sbi, ~0, raw_super->uuid, 2278 sizeof(raw_super->uuid)); 2279 2280 /* 2281 * The BLKZONED feature indicates that the drive was formatted with 2282 * zone alignment optimization. This is optional for host-aware 2283 * devices, but mandatory for host-managed zoned block devices. 2284 */ 2285 #ifndef CONFIG_BLK_DEV_ZONED 2286 if (f2fs_sb_mounted_blkzoned(sb)) { 2287 f2fs_msg(sb, KERN_ERR, 2288 "Zoned block device support is not enabled\n"); 2289 err = -EOPNOTSUPP; 2290 goto free_sb_buf; 2291 } 2292 #endif 2293 default_options(sbi); 2294 /* parse mount options */ 2295 options = kstrdup((const char *)data, GFP_KERNEL); 2296 if (data && !options) { 2297 err = -ENOMEM; 2298 goto free_sb_buf; 2299 } 2300 2301 err = parse_options(sb, options); 2302 if (err) 2303 goto free_options; 2304 2305 sbi->max_file_blocks = max_file_blocks(); 2306 sb->s_maxbytes = sbi->max_file_blocks << 2307 le32_to_cpu(raw_super->log_blocksize); 2308 sb->s_max_links = F2FS_LINK_MAX; 2309 get_random_bytes(&sbi->s_next_generation, sizeof(u32)); 2310 2311 #ifdef CONFIG_QUOTA 2312 sb->dq_op = &f2fs_quota_operations; 2313 sb->s_qcop = &f2fs_quotactl_ops; 2314 sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ; 2315 #endif 2316 2317 sb->s_op = &f2fs_sops; 2318 #ifdef CONFIG_F2FS_FS_ENCRYPTION 2319 sb->s_cop = &f2fs_cryptops; 2320 #endif 2321 sb->s_xattr = f2fs_xattr_handlers; 2322 sb->s_export_op = &f2fs_export_ops; 2323 sb->s_magic = F2FS_SUPER_MAGIC; 2324 sb->s_time_gran = 1; 2325 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | 2326 (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0); 2327 memcpy(&sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid)); 2328 2329 /* init f2fs-specific super block info */ 2330 sbi->valid_super_block = valid_super_block; 2331 mutex_init(&sbi->gc_mutex); 2332 mutex_init(&sbi->cp_mutex); 2333 init_rwsem(&sbi->node_write); 2334 init_rwsem(&sbi->node_change); 2335 2336 /* disallow all the data/node/meta page writes */ 2337 set_sbi_flag(sbi, SBI_POR_DOING); 2338 spin_lock_init(&sbi->stat_lock); 2339 2340 /* init iostat info */ 2341 spin_lock_init(&sbi->iostat_lock); 2342 sbi->iostat_enable = false; 2343 2344 for (i = 0; i < NR_PAGE_TYPE; i++) { 2345 int n = (i == META) ? 1: NR_TEMP_TYPE; 2346 int j; 2347 2348 sbi->write_io[i] = kmalloc(n * sizeof(struct f2fs_bio_info), 2349 GFP_KERNEL); 2350 if (!sbi->write_io[i]) { 2351 err = -ENOMEM; 2352 goto free_options; 2353 } 2354 2355 for (j = HOT; j < n; j++) { 2356 init_rwsem(&sbi->write_io[i][j].io_rwsem); 2357 sbi->write_io[i][j].sbi = sbi; 2358 sbi->write_io[i][j].bio = NULL; 2359 spin_lock_init(&sbi->write_io[i][j].io_lock); 2360 INIT_LIST_HEAD(&sbi->write_io[i][j].io_list); 2361 } 2362 } 2363 2364 init_rwsem(&sbi->cp_rwsem); 2365 init_waitqueue_head(&sbi->cp_wait); 2366 init_sb_info(sbi); 2367 2368 err = init_percpu_info(sbi); 2369 if (err) 2370 goto free_options; 2371 2372 if (F2FS_IO_SIZE(sbi) > 1) { 2373 sbi->write_io_dummy = 2374 mempool_create_page_pool(2 * (F2FS_IO_SIZE(sbi) - 1), 0); 2375 if (!sbi->write_io_dummy) { 2376 err = -ENOMEM; 2377 goto free_options; 2378 } 2379 } 2380 2381 /* get an inode for meta space */ 2382 sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi)); 2383 if (IS_ERR(sbi->meta_inode)) { 2384 f2fs_msg(sb, KERN_ERR, "Failed to read F2FS meta data inode"); 2385 err = PTR_ERR(sbi->meta_inode); 2386 goto free_io_dummy; 2387 } 2388 2389 err = get_valid_checkpoint(sbi); 2390 if (err) { 2391 f2fs_msg(sb, KERN_ERR, "Failed to get valid F2FS checkpoint"); 2392 goto free_meta_inode; 2393 } 2394 2395 /* Initialize device list */ 2396 err = f2fs_scan_devices(sbi); 2397 if (err) { 2398 f2fs_msg(sb, KERN_ERR, "Failed to find devices"); 2399 goto free_devices; 2400 } 2401 2402 sbi->total_valid_node_count = 2403 le32_to_cpu(sbi->ckpt->valid_node_count); 2404 percpu_counter_set(&sbi->total_valid_inode_count, 2405 le32_to_cpu(sbi->ckpt->valid_inode_count)); 2406 sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count); 2407 sbi->total_valid_block_count = 2408 le64_to_cpu(sbi->ckpt->valid_block_count); 2409 sbi->last_valid_block_count = sbi->total_valid_block_count; 2410 sbi->reserved_blocks = 0; 2411 2412 for (i = 0; i < NR_INODE_TYPE; i++) { 2413 INIT_LIST_HEAD(&sbi->inode_list[i]); 2414 spin_lock_init(&sbi->inode_lock[i]); 2415 } 2416 2417 init_extent_cache_info(sbi); 2418 2419 init_ino_entry_info(sbi); 2420 2421 /* setup f2fs internal modules */ 2422 err = build_segment_manager(sbi); 2423 if (err) { 2424 f2fs_msg(sb, KERN_ERR, 2425 "Failed to initialize F2FS segment manager"); 2426 goto free_sm; 2427 } 2428 err = build_node_manager(sbi); 2429 if (err) { 2430 f2fs_msg(sb, KERN_ERR, 2431 "Failed to initialize F2FS node manager"); 2432 goto free_nm; 2433 } 2434 2435 /* For write statistics */ 2436 if (sb->s_bdev->bd_part) 2437 sbi->sectors_written_start = 2438 (u64)part_stat_read(sb->s_bdev->bd_part, sectors[1]); 2439 2440 /* Read accumulated write IO statistics if exists */ 2441 seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE); 2442 if (__exist_node_summaries(sbi)) 2443 sbi->kbytes_written = 2444 le64_to_cpu(seg_i->journal->info.kbytes_written); 2445 2446 build_gc_manager(sbi); 2447 2448 /* get an inode for node space */ 2449 sbi->node_inode = f2fs_iget(sb, F2FS_NODE_INO(sbi)); 2450 if (IS_ERR(sbi->node_inode)) { 2451 f2fs_msg(sb, KERN_ERR, "Failed to read node inode"); 2452 err = PTR_ERR(sbi->node_inode); 2453 goto free_nm; 2454 } 2455 2456 f2fs_join_shrinker(sbi); 2457 2458 err = f2fs_build_stats(sbi); 2459 if (err) 2460 goto free_nm; 2461 2462 /* read root inode and dentry */ 2463 root = f2fs_iget(sb, F2FS_ROOT_INO(sbi)); 2464 if (IS_ERR(root)) { 2465 f2fs_msg(sb, KERN_ERR, "Failed to read root inode"); 2466 err = PTR_ERR(root); 2467 goto free_node_inode; 2468 } 2469 if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) { 2470 iput(root); 2471 err = -EINVAL; 2472 goto free_node_inode; 2473 } 2474 2475 sb->s_root = d_make_root(root); /* allocate root dentry */ 2476 if (!sb->s_root) { 2477 err = -ENOMEM; 2478 goto free_root_inode; 2479 } 2480 2481 err = f2fs_register_sysfs(sbi); 2482 if (err) 2483 goto free_root_inode; 2484 2485 /* if there are nt orphan nodes free them */ 2486 err = recover_orphan_inodes(sbi); 2487 if (err) 2488 goto free_sysfs; 2489 2490 /* recover fsynced data */ 2491 if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) { 2492 /* 2493 * mount should be failed, when device has readonly mode, and 2494 * previous checkpoint was not done by clean system shutdown. 2495 */ 2496 if (bdev_read_only(sb->s_bdev) && 2497 !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) { 2498 err = -EROFS; 2499 goto free_meta; 2500 } 2501 2502 if (need_fsck) 2503 set_sbi_flag(sbi, SBI_NEED_FSCK); 2504 2505 if (!retry) 2506 goto skip_recovery; 2507 2508 err = recover_fsync_data(sbi, false); 2509 if (err < 0) { 2510 need_fsck = true; 2511 f2fs_msg(sb, KERN_ERR, 2512 "Cannot recover all fsync data errno=%d", err); 2513 goto free_meta; 2514 } 2515 } else { 2516 err = recover_fsync_data(sbi, true); 2517 2518 if (!f2fs_readonly(sb) && err > 0) { 2519 err = -EINVAL; 2520 f2fs_msg(sb, KERN_ERR, 2521 "Need to recover fsync data"); 2522 goto free_sysfs; 2523 } 2524 } 2525 skip_recovery: 2526 /* recover_fsync_data() cleared this already */ 2527 clear_sbi_flag(sbi, SBI_POR_DOING); 2528 2529 /* 2530 * If filesystem is not mounted as read-only then 2531 * do start the gc_thread. 2532 */ 2533 if (test_opt(sbi, BG_GC) && !f2fs_readonly(sb)) { 2534 /* After POR, we can run background GC thread.*/ 2535 err = start_gc_thread(sbi); 2536 if (err) 2537 goto free_meta; 2538 } 2539 kfree(options); 2540 2541 /* recover broken superblock */ 2542 if (recovery) { 2543 err = f2fs_commit_super(sbi, true); 2544 f2fs_msg(sb, KERN_INFO, 2545 "Try to recover %dth superblock, ret: %d", 2546 sbi->valid_super_block ? 1 : 2, err); 2547 } 2548 2549 f2fs_msg(sbi->sb, KERN_NOTICE, "Mounted with checkpoint version = %llx", 2550 cur_cp_version(F2FS_CKPT(sbi))); 2551 f2fs_update_time(sbi, CP_TIME); 2552 f2fs_update_time(sbi, REQ_TIME); 2553 return 0; 2554 2555 free_meta: 2556 f2fs_sync_inode_meta(sbi); 2557 /* 2558 * Some dirty meta pages can be produced by recover_orphan_inodes() 2559 * failed by EIO. Then, iput(node_inode) can trigger balance_fs_bg() 2560 * followed by write_checkpoint() through f2fs_write_node_pages(), which 2561 * falls into an infinite loop in sync_meta_pages(). 2562 */ 2563 truncate_inode_pages_final(META_MAPPING(sbi)); 2564 free_sysfs: 2565 f2fs_unregister_sysfs(sbi); 2566 free_root_inode: 2567 dput(sb->s_root); 2568 sb->s_root = NULL; 2569 free_node_inode: 2570 truncate_inode_pages_final(NODE_MAPPING(sbi)); 2571 mutex_lock(&sbi->umount_mutex); 2572 release_ino_entry(sbi, true); 2573 f2fs_leave_shrinker(sbi); 2574 iput(sbi->node_inode); 2575 mutex_unlock(&sbi->umount_mutex); 2576 f2fs_destroy_stats(sbi); 2577 free_nm: 2578 destroy_node_manager(sbi); 2579 free_sm: 2580 destroy_segment_manager(sbi); 2581 free_devices: 2582 destroy_device_list(sbi); 2583 kfree(sbi->ckpt); 2584 free_meta_inode: 2585 make_bad_inode(sbi->meta_inode); 2586 iput(sbi->meta_inode); 2587 free_io_dummy: 2588 mempool_destroy(sbi->write_io_dummy); 2589 free_options: 2590 for (i = 0; i < NR_PAGE_TYPE; i++) 2591 kfree(sbi->write_io[i]); 2592 destroy_percpu_info(sbi); 2593 #ifdef CONFIG_QUOTA 2594 for (i = 0; i < MAXQUOTAS; i++) 2595 kfree(sbi->s_qf_names[i]); 2596 #endif 2597 kfree(options); 2598 free_sb_buf: 2599 kfree(raw_super); 2600 free_sbi: 2601 if (sbi->s_chksum_driver) 2602 crypto_free_shash(sbi->s_chksum_driver); 2603 kfree(sbi); 2604 2605 /* give only one another chance */ 2606 if (retry) { 2607 retry = false; 2608 shrink_dcache_sb(sb); 2609 goto try_onemore; 2610 } 2611 return err; 2612 } 2613 2614 static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags, 2615 const char *dev_name, void *data) 2616 { 2617 return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super); 2618 } 2619 2620 static void kill_f2fs_super(struct super_block *sb) 2621 { 2622 if (sb->s_root) { 2623 set_sbi_flag(F2FS_SB(sb), SBI_IS_CLOSE); 2624 stop_gc_thread(F2FS_SB(sb)); 2625 stop_discard_thread(F2FS_SB(sb)); 2626 } 2627 kill_block_super(sb); 2628 } 2629 2630 static struct file_system_type f2fs_fs_type = { 2631 .owner = THIS_MODULE, 2632 .name = "f2fs", 2633 .mount = f2fs_mount, 2634 .kill_sb = kill_f2fs_super, 2635 .fs_flags = FS_REQUIRES_DEV, 2636 }; 2637 MODULE_ALIAS_FS("f2fs"); 2638 2639 static int __init init_inodecache(void) 2640 { 2641 f2fs_inode_cachep = kmem_cache_create("f2fs_inode_cache", 2642 sizeof(struct f2fs_inode_info), 0, 2643 SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT, NULL); 2644 if (!f2fs_inode_cachep) 2645 return -ENOMEM; 2646 return 0; 2647 } 2648 2649 static void destroy_inodecache(void) 2650 { 2651 /* 2652 * Make sure all delayed rcu free inodes are flushed before we 2653 * destroy cache. 2654 */ 2655 rcu_barrier(); 2656 kmem_cache_destroy(f2fs_inode_cachep); 2657 } 2658 2659 static int __init init_f2fs_fs(void) 2660 { 2661 int err; 2662 2663 f2fs_build_trace_ios(); 2664 2665 err = init_inodecache(); 2666 if (err) 2667 goto fail; 2668 err = create_node_manager_caches(); 2669 if (err) 2670 goto free_inodecache; 2671 err = create_segment_manager_caches(); 2672 if (err) 2673 goto free_node_manager_caches; 2674 err = create_checkpoint_caches(); 2675 if (err) 2676 goto free_segment_manager_caches; 2677 err = create_extent_cache(); 2678 if (err) 2679 goto free_checkpoint_caches; 2680 err = f2fs_init_sysfs(); 2681 if (err) 2682 goto free_extent_cache; 2683 err = register_shrinker(&f2fs_shrinker_info); 2684 if (err) 2685 goto free_sysfs; 2686 err = register_filesystem(&f2fs_fs_type); 2687 if (err) 2688 goto free_shrinker; 2689 err = f2fs_create_root_stats(); 2690 if (err) 2691 goto free_filesystem; 2692 return 0; 2693 2694 free_filesystem: 2695 unregister_filesystem(&f2fs_fs_type); 2696 free_shrinker: 2697 unregister_shrinker(&f2fs_shrinker_info); 2698 free_sysfs: 2699 f2fs_exit_sysfs(); 2700 free_extent_cache: 2701 destroy_extent_cache(); 2702 free_checkpoint_caches: 2703 destroy_checkpoint_caches(); 2704 free_segment_manager_caches: 2705 destroy_segment_manager_caches(); 2706 free_node_manager_caches: 2707 destroy_node_manager_caches(); 2708 free_inodecache: 2709 destroy_inodecache(); 2710 fail: 2711 return err; 2712 } 2713 2714 static void __exit exit_f2fs_fs(void) 2715 { 2716 f2fs_destroy_root_stats(); 2717 unregister_filesystem(&f2fs_fs_type); 2718 unregister_shrinker(&f2fs_shrinker_info); 2719 f2fs_exit_sysfs(); 2720 destroy_extent_cache(); 2721 destroy_checkpoint_caches(); 2722 destroy_segment_manager_caches(); 2723 destroy_node_manager_caches(); 2724 destroy_inodecache(); 2725 f2fs_destroy_trace_ios(); 2726 } 2727 2728 module_init(init_f2fs_fs) 2729 module_exit(exit_f2fs_fs) 2730 2731 MODULE_AUTHOR("Samsung Electronics's Praesto Team"); 2732 MODULE_DESCRIPTION("Flash Friendly File System"); 2733 MODULE_LICENSE("GPL"); 2734 2735