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/f2fs_fs.h> 26 #include <linux/sysfs.h> 27 28 #include "f2fs.h" 29 #include "node.h" 30 #include "segment.h" 31 #include "xattr.h" 32 #include "gc.h" 33 #include "trace.h" 34 35 #define CREATE_TRACE_POINTS 36 #include <trace/events/f2fs.h> 37 38 static struct proc_dir_entry *f2fs_proc_root; 39 static struct kmem_cache *f2fs_inode_cachep; 40 static struct kset *f2fs_kset; 41 42 /* f2fs-wide shrinker description */ 43 static struct shrinker f2fs_shrinker_info = { 44 .scan_objects = f2fs_shrink_scan, 45 .count_objects = f2fs_shrink_count, 46 .seeks = DEFAULT_SEEKS, 47 }; 48 49 enum { 50 Opt_gc_background, 51 Opt_disable_roll_forward, 52 Opt_norecovery, 53 Opt_discard, 54 Opt_noheap, 55 Opt_user_xattr, 56 Opt_nouser_xattr, 57 Opt_acl, 58 Opt_noacl, 59 Opt_active_logs, 60 Opt_disable_ext_identify, 61 Opt_inline_xattr, 62 Opt_inline_data, 63 Opt_inline_dentry, 64 Opt_flush_merge, 65 Opt_nobarrier, 66 Opt_fastboot, 67 Opt_extent_cache, 68 Opt_noextent_cache, 69 Opt_noinline_data, 70 Opt_err, 71 }; 72 73 static match_table_t f2fs_tokens = { 74 {Opt_gc_background, "background_gc=%s"}, 75 {Opt_disable_roll_forward, "disable_roll_forward"}, 76 {Opt_norecovery, "norecovery"}, 77 {Opt_discard, "discard"}, 78 {Opt_noheap, "no_heap"}, 79 {Opt_user_xattr, "user_xattr"}, 80 {Opt_nouser_xattr, "nouser_xattr"}, 81 {Opt_acl, "acl"}, 82 {Opt_noacl, "noacl"}, 83 {Opt_active_logs, "active_logs=%u"}, 84 {Opt_disable_ext_identify, "disable_ext_identify"}, 85 {Opt_inline_xattr, "inline_xattr"}, 86 {Opt_inline_data, "inline_data"}, 87 {Opt_inline_dentry, "inline_dentry"}, 88 {Opt_flush_merge, "flush_merge"}, 89 {Opt_nobarrier, "nobarrier"}, 90 {Opt_fastboot, "fastboot"}, 91 {Opt_extent_cache, "extent_cache"}, 92 {Opt_noextent_cache, "noextent_cache"}, 93 {Opt_noinline_data, "noinline_data"}, 94 {Opt_err, NULL}, 95 }; 96 97 /* Sysfs support for f2fs */ 98 enum { 99 GC_THREAD, /* struct f2fs_gc_thread */ 100 SM_INFO, /* struct f2fs_sm_info */ 101 NM_INFO, /* struct f2fs_nm_info */ 102 F2FS_SBI, /* struct f2fs_sb_info */ 103 }; 104 105 struct f2fs_attr { 106 struct attribute attr; 107 ssize_t (*show)(struct f2fs_attr *, struct f2fs_sb_info *, char *); 108 ssize_t (*store)(struct f2fs_attr *, struct f2fs_sb_info *, 109 const char *, size_t); 110 int struct_type; 111 int offset; 112 }; 113 114 static unsigned char *__struct_ptr(struct f2fs_sb_info *sbi, int struct_type) 115 { 116 if (struct_type == GC_THREAD) 117 return (unsigned char *)sbi->gc_thread; 118 else if (struct_type == SM_INFO) 119 return (unsigned char *)SM_I(sbi); 120 else if (struct_type == NM_INFO) 121 return (unsigned char *)NM_I(sbi); 122 else if (struct_type == F2FS_SBI) 123 return (unsigned char *)sbi; 124 return NULL; 125 } 126 127 static ssize_t f2fs_sbi_show(struct f2fs_attr *a, 128 struct f2fs_sb_info *sbi, char *buf) 129 { 130 unsigned char *ptr = NULL; 131 unsigned int *ui; 132 133 ptr = __struct_ptr(sbi, a->struct_type); 134 if (!ptr) 135 return -EINVAL; 136 137 ui = (unsigned int *)(ptr + a->offset); 138 139 return snprintf(buf, PAGE_SIZE, "%u\n", *ui); 140 } 141 142 static ssize_t f2fs_sbi_store(struct f2fs_attr *a, 143 struct f2fs_sb_info *sbi, 144 const char *buf, size_t count) 145 { 146 unsigned char *ptr; 147 unsigned long t; 148 unsigned int *ui; 149 ssize_t ret; 150 151 ptr = __struct_ptr(sbi, a->struct_type); 152 if (!ptr) 153 return -EINVAL; 154 155 ui = (unsigned int *)(ptr + a->offset); 156 157 ret = kstrtoul(skip_spaces(buf), 0, &t); 158 if (ret < 0) 159 return ret; 160 *ui = t; 161 return count; 162 } 163 164 static ssize_t f2fs_attr_show(struct kobject *kobj, 165 struct attribute *attr, char *buf) 166 { 167 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 168 s_kobj); 169 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); 170 171 return a->show ? a->show(a, sbi, buf) : 0; 172 } 173 174 static ssize_t f2fs_attr_store(struct kobject *kobj, struct attribute *attr, 175 const char *buf, size_t len) 176 { 177 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 178 s_kobj); 179 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); 180 181 return a->store ? a->store(a, sbi, buf, len) : 0; 182 } 183 184 static void f2fs_sb_release(struct kobject *kobj) 185 { 186 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 187 s_kobj); 188 complete(&sbi->s_kobj_unregister); 189 } 190 191 #define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \ 192 static struct f2fs_attr f2fs_attr_##_name = { \ 193 .attr = {.name = __stringify(_name), .mode = _mode }, \ 194 .show = _show, \ 195 .store = _store, \ 196 .struct_type = _struct_type, \ 197 .offset = _offset \ 198 } 199 200 #define F2FS_RW_ATTR(struct_type, struct_name, name, elname) \ 201 F2FS_ATTR_OFFSET(struct_type, name, 0644, \ 202 f2fs_sbi_show, f2fs_sbi_store, \ 203 offsetof(struct struct_name, elname)) 204 205 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time); 206 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time); 207 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time); 208 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_idle, gc_idle); 209 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments); 210 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, max_small_discards, max_discards); 211 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections); 212 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy); 213 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util); 214 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); 215 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh); 216 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search); 217 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level); 218 219 #define ATTR_LIST(name) (&f2fs_attr_##name.attr) 220 static struct attribute *f2fs_attrs[] = { 221 ATTR_LIST(gc_min_sleep_time), 222 ATTR_LIST(gc_max_sleep_time), 223 ATTR_LIST(gc_no_gc_sleep_time), 224 ATTR_LIST(gc_idle), 225 ATTR_LIST(reclaim_segments), 226 ATTR_LIST(max_small_discards), 227 ATTR_LIST(batched_trim_sections), 228 ATTR_LIST(ipu_policy), 229 ATTR_LIST(min_ipu_util), 230 ATTR_LIST(min_fsync_blocks), 231 ATTR_LIST(max_victim_search), 232 ATTR_LIST(dir_level), 233 ATTR_LIST(ram_thresh), 234 NULL, 235 }; 236 237 static const struct sysfs_ops f2fs_attr_ops = { 238 .show = f2fs_attr_show, 239 .store = f2fs_attr_store, 240 }; 241 242 static struct kobj_type f2fs_ktype = { 243 .default_attrs = f2fs_attrs, 244 .sysfs_ops = &f2fs_attr_ops, 245 .release = f2fs_sb_release, 246 }; 247 248 void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...) 249 { 250 struct va_format vaf; 251 va_list args; 252 253 va_start(args, fmt); 254 vaf.fmt = fmt; 255 vaf.va = &args; 256 printk("%sF2FS-fs (%s): %pV\n", level, sb->s_id, &vaf); 257 va_end(args); 258 } 259 260 static void init_once(void *foo) 261 { 262 struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo; 263 264 inode_init_once(&fi->vfs_inode); 265 } 266 267 static int parse_options(struct super_block *sb, char *options) 268 { 269 struct f2fs_sb_info *sbi = F2FS_SB(sb); 270 struct request_queue *q; 271 substring_t args[MAX_OPT_ARGS]; 272 char *p, *name; 273 int arg = 0; 274 275 if (!options) 276 return 0; 277 278 while ((p = strsep(&options, ",")) != NULL) { 279 int token; 280 if (!*p) 281 continue; 282 /* 283 * Initialize args struct so we know whether arg was 284 * found; some options take optional arguments. 285 */ 286 args[0].to = args[0].from = NULL; 287 token = match_token(p, f2fs_tokens, args); 288 289 switch (token) { 290 case Opt_gc_background: 291 name = match_strdup(&args[0]); 292 293 if (!name) 294 return -ENOMEM; 295 if (strlen(name) == 2 && !strncmp(name, "on", 2)) 296 set_opt(sbi, BG_GC); 297 else if (strlen(name) == 3 && !strncmp(name, "off", 3)) 298 clear_opt(sbi, BG_GC); 299 else { 300 kfree(name); 301 return -EINVAL; 302 } 303 kfree(name); 304 break; 305 case Opt_disable_roll_forward: 306 set_opt(sbi, DISABLE_ROLL_FORWARD); 307 break; 308 case Opt_norecovery: 309 /* this option mounts f2fs with ro */ 310 set_opt(sbi, DISABLE_ROLL_FORWARD); 311 if (!f2fs_readonly(sb)) 312 return -EINVAL; 313 break; 314 case Opt_discard: 315 q = bdev_get_queue(sb->s_bdev); 316 if (blk_queue_discard(q)) { 317 set_opt(sbi, DISCARD); 318 } else { 319 f2fs_msg(sb, KERN_WARNING, 320 "mounting with \"discard\" option, but " 321 "the device does not support discard"); 322 } 323 break; 324 case Opt_noheap: 325 set_opt(sbi, NOHEAP); 326 break; 327 #ifdef CONFIG_F2FS_FS_XATTR 328 case Opt_user_xattr: 329 set_opt(sbi, XATTR_USER); 330 break; 331 case Opt_nouser_xattr: 332 clear_opt(sbi, XATTR_USER); 333 break; 334 case Opt_inline_xattr: 335 set_opt(sbi, INLINE_XATTR); 336 break; 337 #else 338 case Opt_user_xattr: 339 f2fs_msg(sb, KERN_INFO, 340 "user_xattr options not supported"); 341 break; 342 case Opt_nouser_xattr: 343 f2fs_msg(sb, KERN_INFO, 344 "nouser_xattr options not supported"); 345 break; 346 case Opt_inline_xattr: 347 f2fs_msg(sb, KERN_INFO, 348 "inline_xattr options not supported"); 349 break; 350 #endif 351 #ifdef CONFIG_F2FS_FS_POSIX_ACL 352 case Opt_acl: 353 set_opt(sbi, POSIX_ACL); 354 break; 355 case Opt_noacl: 356 clear_opt(sbi, POSIX_ACL); 357 break; 358 #else 359 case Opt_acl: 360 f2fs_msg(sb, KERN_INFO, "acl options not supported"); 361 break; 362 case Opt_noacl: 363 f2fs_msg(sb, KERN_INFO, "noacl options not supported"); 364 break; 365 #endif 366 case Opt_active_logs: 367 if (args->from && match_int(args, &arg)) 368 return -EINVAL; 369 if (arg != 2 && arg != 4 && arg != NR_CURSEG_TYPE) 370 return -EINVAL; 371 sbi->active_logs = arg; 372 break; 373 case Opt_disable_ext_identify: 374 set_opt(sbi, DISABLE_EXT_IDENTIFY); 375 break; 376 case Opt_inline_data: 377 set_opt(sbi, INLINE_DATA); 378 break; 379 case Opt_inline_dentry: 380 set_opt(sbi, INLINE_DENTRY); 381 break; 382 case Opt_flush_merge: 383 set_opt(sbi, FLUSH_MERGE); 384 break; 385 case Opt_nobarrier: 386 set_opt(sbi, NOBARRIER); 387 break; 388 case Opt_fastboot: 389 set_opt(sbi, FASTBOOT); 390 break; 391 case Opt_extent_cache: 392 set_opt(sbi, EXTENT_CACHE); 393 break; 394 case Opt_noextent_cache: 395 clear_opt(sbi, EXTENT_CACHE); 396 break; 397 case Opt_noinline_data: 398 clear_opt(sbi, INLINE_DATA); 399 break; 400 default: 401 f2fs_msg(sb, KERN_ERR, 402 "Unrecognized mount option \"%s\" or missing value", 403 p); 404 return -EINVAL; 405 } 406 } 407 return 0; 408 } 409 410 static struct inode *f2fs_alloc_inode(struct super_block *sb) 411 { 412 struct f2fs_inode_info *fi; 413 414 fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_F2FS_ZERO); 415 if (!fi) 416 return NULL; 417 418 init_once((void *) fi); 419 420 /* Initialize f2fs-specific inode info */ 421 fi->vfs_inode.i_version = 1; 422 atomic_set(&fi->dirty_pages, 0); 423 fi->i_current_depth = 1; 424 fi->i_advise = 0; 425 init_rwsem(&fi->i_sem); 426 INIT_LIST_HEAD(&fi->inmem_pages); 427 mutex_init(&fi->inmem_lock); 428 429 set_inode_flag(fi, FI_NEW_INODE); 430 431 if (test_opt(F2FS_SB(sb), INLINE_XATTR)) 432 set_inode_flag(fi, FI_INLINE_XATTR); 433 434 /* Will be used by directory only */ 435 fi->i_dir_level = F2FS_SB(sb)->dir_level; 436 437 #ifdef CONFIG_F2FS_FS_ENCRYPTION 438 fi->i_crypt_info = NULL; 439 #endif 440 return &fi->vfs_inode; 441 } 442 443 static int f2fs_drop_inode(struct inode *inode) 444 { 445 /* 446 * This is to avoid a deadlock condition like below. 447 * writeback_single_inode(inode) 448 * - f2fs_write_data_page 449 * - f2fs_gc -> iput -> evict 450 * - inode_wait_for_writeback(inode) 451 */ 452 if (!inode_unhashed(inode) && inode->i_state & I_SYNC) { 453 if (!inode->i_nlink && !is_bad_inode(inode)) { 454 /* to avoid evict_inode call simultaneously */ 455 atomic_inc(&inode->i_count); 456 spin_unlock(&inode->i_lock); 457 458 /* some remained atomic pages should discarded */ 459 if (f2fs_is_atomic_file(inode)) 460 commit_inmem_pages(inode, true); 461 462 /* should remain fi->extent_tree for writepage */ 463 f2fs_destroy_extent_node(inode); 464 465 sb_start_intwrite(inode->i_sb); 466 i_size_write(inode, 0); 467 468 if (F2FS_HAS_BLOCKS(inode)) 469 f2fs_truncate(inode, true); 470 471 sb_end_intwrite(inode->i_sb); 472 473 #ifdef CONFIG_F2FS_FS_ENCRYPTION 474 if (F2FS_I(inode)->i_crypt_info) 475 f2fs_free_encryption_info(inode, 476 F2FS_I(inode)->i_crypt_info); 477 #endif 478 spin_lock(&inode->i_lock); 479 atomic_dec(&inode->i_count); 480 } 481 return 0; 482 } 483 return generic_drop_inode(inode); 484 } 485 486 /* 487 * f2fs_dirty_inode() is called from __mark_inode_dirty() 488 * 489 * We should call set_dirty_inode to write the dirty inode through write_inode. 490 */ 491 static void f2fs_dirty_inode(struct inode *inode, int flags) 492 { 493 set_inode_flag(F2FS_I(inode), FI_DIRTY_INODE); 494 } 495 496 static void f2fs_i_callback(struct rcu_head *head) 497 { 498 struct inode *inode = container_of(head, struct inode, i_rcu); 499 kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode)); 500 } 501 502 static void f2fs_destroy_inode(struct inode *inode) 503 { 504 call_rcu(&inode->i_rcu, f2fs_i_callback); 505 } 506 507 static void f2fs_put_super(struct super_block *sb) 508 { 509 struct f2fs_sb_info *sbi = F2FS_SB(sb); 510 511 if (sbi->s_proc) { 512 remove_proc_entry("segment_info", sbi->s_proc); 513 remove_proc_entry(sb->s_id, f2fs_proc_root); 514 } 515 kobject_del(&sbi->s_kobj); 516 517 stop_gc_thread(sbi); 518 519 /* prevent remaining shrinker jobs */ 520 mutex_lock(&sbi->umount_mutex); 521 522 /* 523 * We don't need to do checkpoint when superblock is clean. 524 * But, the previous checkpoint was not done by umount, it needs to do 525 * clean checkpoint again. 526 */ 527 if (is_sbi_flag_set(sbi, SBI_IS_DIRTY) || 528 !is_set_ckpt_flags(F2FS_CKPT(sbi), CP_UMOUNT_FLAG)) { 529 struct cp_control cpc = { 530 .reason = CP_UMOUNT, 531 }; 532 write_checkpoint(sbi, &cpc); 533 } 534 535 /* write_checkpoint can update stat informaion */ 536 f2fs_destroy_stats(sbi); 537 538 /* 539 * normally superblock is clean, so we need to release this. 540 * In addition, EIO will skip do checkpoint, we need this as well. 541 */ 542 release_dirty_inode(sbi); 543 release_discard_addrs(sbi); 544 545 f2fs_leave_shrinker(sbi); 546 mutex_unlock(&sbi->umount_mutex); 547 548 iput(sbi->node_inode); 549 iput(sbi->meta_inode); 550 551 /* destroy f2fs internal modules */ 552 destroy_node_manager(sbi); 553 destroy_segment_manager(sbi); 554 555 kfree(sbi->ckpt); 556 kobject_put(&sbi->s_kobj); 557 wait_for_completion(&sbi->s_kobj_unregister); 558 559 sb->s_fs_info = NULL; 560 brelse(sbi->raw_super_buf); 561 kfree(sbi); 562 } 563 564 int f2fs_sync_fs(struct super_block *sb, int sync) 565 { 566 struct f2fs_sb_info *sbi = F2FS_SB(sb); 567 568 trace_f2fs_sync_fs(sb, sync); 569 570 if (sync) { 571 struct cp_control cpc; 572 573 cpc.reason = __get_cp_reason(sbi); 574 575 mutex_lock(&sbi->gc_mutex); 576 write_checkpoint(sbi, &cpc); 577 mutex_unlock(&sbi->gc_mutex); 578 } else { 579 f2fs_balance_fs(sbi); 580 } 581 f2fs_trace_ios(NULL, 1); 582 583 return 0; 584 } 585 586 static int f2fs_freeze(struct super_block *sb) 587 { 588 int err; 589 590 if (f2fs_readonly(sb)) 591 return 0; 592 593 err = f2fs_sync_fs(sb, 1); 594 return err; 595 } 596 597 static int f2fs_unfreeze(struct super_block *sb) 598 { 599 return 0; 600 } 601 602 static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf) 603 { 604 struct super_block *sb = dentry->d_sb; 605 struct f2fs_sb_info *sbi = F2FS_SB(sb); 606 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 607 block_t total_count, user_block_count, start_count, ovp_count; 608 609 total_count = le64_to_cpu(sbi->raw_super->block_count); 610 user_block_count = sbi->user_block_count; 611 start_count = le32_to_cpu(sbi->raw_super->segment0_blkaddr); 612 ovp_count = SM_I(sbi)->ovp_segments << sbi->log_blocks_per_seg; 613 buf->f_type = F2FS_SUPER_MAGIC; 614 buf->f_bsize = sbi->blocksize; 615 616 buf->f_blocks = total_count - start_count; 617 buf->f_bfree = buf->f_blocks - valid_user_blocks(sbi) - ovp_count; 618 buf->f_bavail = user_block_count - valid_user_blocks(sbi); 619 620 buf->f_files = sbi->total_node_count - F2FS_RESERVED_NODE_NUM; 621 buf->f_ffree = buf->f_files - valid_inode_count(sbi); 622 623 buf->f_namelen = F2FS_NAME_LEN; 624 buf->f_fsid.val[0] = (u32)id; 625 buf->f_fsid.val[1] = (u32)(id >> 32); 626 627 return 0; 628 } 629 630 static int f2fs_show_options(struct seq_file *seq, struct dentry *root) 631 { 632 struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb); 633 634 if (!f2fs_readonly(sbi->sb) && test_opt(sbi, BG_GC)) 635 seq_printf(seq, ",background_gc=%s", "on"); 636 else 637 seq_printf(seq, ",background_gc=%s", "off"); 638 if (test_opt(sbi, DISABLE_ROLL_FORWARD)) 639 seq_puts(seq, ",disable_roll_forward"); 640 if (test_opt(sbi, DISCARD)) 641 seq_puts(seq, ",discard"); 642 if (test_opt(sbi, NOHEAP)) 643 seq_puts(seq, ",no_heap_alloc"); 644 #ifdef CONFIG_F2FS_FS_XATTR 645 if (test_opt(sbi, XATTR_USER)) 646 seq_puts(seq, ",user_xattr"); 647 else 648 seq_puts(seq, ",nouser_xattr"); 649 if (test_opt(sbi, INLINE_XATTR)) 650 seq_puts(seq, ",inline_xattr"); 651 #endif 652 #ifdef CONFIG_F2FS_FS_POSIX_ACL 653 if (test_opt(sbi, POSIX_ACL)) 654 seq_puts(seq, ",acl"); 655 else 656 seq_puts(seq, ",noacl"); 657 #endif 658 if (test_opt(sbi, DISABLE_EXT_IDENTIFY)) 659 seq_puts(seq, ",disable_ext_identify"); 660 if (test_opt(sbi, INLINE_DATA)) 661 seq_puts(seq, ",inline_data"); 662 else 663 seq_puts(seq, ",noinline_data"); 664 if (test_opt(sbi, INLINE_DENTRY)) 665 seq_puts(seq, ",inline_dentry"); 666 if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE)) 667 seq_puts(seq, ",flush_merge"); 668 if (test_opt(sbi, NOBARRIER)) 669 seq_puts(seq, ",nobarrier"); 670 if (test_opt(sbi, FASTBOOT)) 671 seq_puts(seq, ",fastboot"); 672 if (test_opt(sbi, EXTENT_CACHE)) 673 seq_puts(seq, ",extent_cache"); 674 else 675 seq_puts(seq, ",noextent_cache"); 676 seq_printf(seq, ",active_logs=%u", sbi->active_logs); 677 678 return 0; 679 } 680 681 static int segment_info_seq_show(struct seq_file *seq, void *offset) 682 { 683 struct super_block *sb = seq->private; 684 struct f2fs_sb_info *sbi = F2FS_SB(sb); 685 unsigned int total_segs = 686 le32_to_cpu(sbi->raw_super->segment_count_main); 687 int i; 688 689 seq_puts(seq, "format: segment_type|valid_blocks\n" 690 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n"); 691 692 for (i = 0; i < total_segs; i++) { 693 struct seg_entry *se = get_seg_entry(sbi, i); 694 695 if ((i % 10) == 0) 696 seq_printf(seq, "%-10d", i); 697 seq_printf(seq, "%d|%-3u", se->type, 698 get_valid_blocks(sbi, i, 1)); 699 if ((i % 10) == 9 || i == (total_segs - 1)) 700 seq_putc(seq, '\n'); 701 else 702 seq_putc(seq, ' '); 703 } 704 705 return 0; 706 } 707 708 static int segment_info_open_fs(struct inode *inode, struct file *file) 709 { 710 return single_open(file, segment_info_seq_show, PDE_DATA(inode)); 711 } 712 713 static const struct file_operations f2fs_seq_segment_info_fops = { 714 .owner = THIS_MODULE, 715 .open = segment_info_open_fs, 716 .read = seq_read, 717 .llseek = seq_lseek, 718 .release = single_release, 719 }; 720 721 static void default_options(struct f2fs_sb_info *sbi) 722 { 723 /* init some FS parameters */ 724 sbi->active_logs = NR_CURSEG_TYPE; 725 726 set_opt(sbi, BG_GC); 727 set_opt(sbi, INLINE_DATA); 728 set_opt(sbi, EXTENT_CACHE); 729 730 #ifdef CONFIG_F2FS_FS_XATTR 731 set_opt(sbi, XATTR_USER); 732 #endif 733 #ifdef CONFIG_F2FS_FS_POSIX_ACL 734 set_opt(sbi, POSIX_ACL); 735 #endif 736 } 737 738 static int f2fs_remount(struct super_block *sb, int *flags, char *data) 739 { 740 struct f2fs_sb_info *sbi = F2FS_SB(sb); 741 struct f2fs_mount_info org_mount_opt; 742 int err, active_logs; 743 bool need_restart_gc = false; 744 bool need_stop_gc = false; 745 746 sync_filesystem(sb); 747 748 /* 749 * Save the old mount options in case we 750 * need to restore them. 751 */ 752 org_mount_opt = sbi->mount_opt; 753 active_logs = sbi->active_logs; 754 755 sbi->mount_opt.opt = 0; 756 default_options(sbi); 757 758 /* parse mount options */ 759 err = parse_options(sb, data); 760 if (err) 761 goto restore_opts; 762 763 /* 764 * Previous and new state of filesystem is RO, 765 * so skip checking GC and FLUSH_MERGE conditions. 766 */ 767 if (f2fs_readonly(sb) && (*flags & MS_RDONLY)) 768 goto skip; 769 770 /* 771 * We stop the GC thread if FS is mounted as RO 772 * or if background_gc = off is passed in mount 773 * option. Also sync the filesystem. 774 */ 775 if ((*flags & MS_RDONLY) || !test_opt(sbi, BG_GC)) { 776 if (sbi->gc_thread) { 777 stop_gc_thread(sbi); 778 f2fs_sync_fs(sb, 1); 779 need_restart_gc = true; 780 } 781 } else if (!sbi->gc_thread) { 782 err = start_gc_thread(sbi); 783 if (err) 784 goto restore_opts; 785 need_stop_gc = true; 786 } 787 788 /* 789 * We stop issue flush thread if FS is mounted as RO 790 * or if flush_merge is not passed in mount option. 791 */ 792 if ((*flags & MS_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) { 793 destroy_flush_cmd_control(sbi); 794 } else if (!SM_I(sbi)->cmd_control_info) { 795 err = create_flush_cmd_control(sbi); 796 if (err) 797 goto restore_gc; 798 } 799 skip: 800 /* Update the POSIXACL Flag */ 801 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | 802 (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0); 803 return 0; 804 restore_gc: 805 if (need_restart_gc) { 806 if (start_gc_thread(sbi)) 807 f2fs_msg(sbi->sb, KERN_WARNING, 808 "background gc thread has stopped"); 809 } else if (need_stop_gc) { 810 stop_gc_thread(sbi); 811 } 812 restore_opts: 813 sbi->mount_opt = org_mount_opt; 814 sbi->active_logs = active_logs; 815 return err; 816 } 817 818 static struct super_operations f2fs_sops = { 819 .alloc_inode = f2fs_alloc_inode, 820 .drop_inode = f2fs_drop_inode, 821 .destroy_inode = f2fs_destroy_inode, 822 .write_inode = f2fs_write_inode, 823 .dirty_inode = f2fs_dirty_inode, 824 .show_options = f2fs_show_options, 825 .evict_inode = f2fs_evict_inode, 826 .put_super = f2fs_put_super, 827 .sync_fs = f2fs_sync_fs, 828 .freeze_fs = f2fs_freeze, 829 .unfreeze_fs = f2fs_unfreeze, 830 .statfs = f2fs_statfs, 831 .remount_fs = f2fs_remount, 832 }; 833 834 static struct inode *f2fs_nfs_get_inode(struct super_block *sb, 835 u64 ino, u32 generation) 836 { 837 struct f2fs_sb_info *sbi = F2FS_SB(sb); 838 struct inode *inode; 839 840 if (check_nid_range(sbi, ino)) 841 return ERR_PTR(-ESTALE); 842 843 /* 844 * f2fs_iget isn't quite right if the inode is currently unallocated! 845 * However f2fs_iget currently does appropriate checks to handle stale 846 * inodes so everything is OK. 847 */ 848 inode = f2fs_iget(sb, ino); 849 if (IS_ERR(inode)) 850 return ERR_CAST(inode); 851 if (unlikely(generation && inode->i_generation != generation)) { 852 /* we didn't find the right inode.. */ 853 iput(inode); 854 return ERR_PTR(-ESTALE); 855 } 856 return inode; 857 } 858 859 static struct dentry *f2fs_fh_to_dentry(struct super_block *sb, struct fid *fid, 860 int fh_len, int fh_type) 861 { 862 return generic_fh_to_dentry(sb, fid, fh_len, fh_type, 863 f2fs_nfs_get_inode); 864 } 865 866 static struct dentry *f2fs_fh_to_parent(struct super_block *sb, struct fid *fid, 867 int fh_len, int fh_type) 868 { 869 return generic_fh_to_parent(sb, fid, fh_len, fh_type, 870 f2fs_nfs_get_inode); 871 } 872 873 static const struct export_operations f2fs_export_ops = { 874 .fh_to_dentry = f2fs_fh_to_dentry, 875 .fh_to_parent = f2fs_fh_to_parent, 876 .get_parent = f2fs_get_parent, 877 }; 878 879 static loff_t max_file_size(unsigned bits) 880 { 881 loff_t result = (DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS); 882 loff_t leaf_count = ADDRS_PER_BLOCK; 883 884 /* two direct node blocks */ 885 result += (leaf_count * 2); 886 887 /* two indirect node blocks */ 888 leaf_count *= NIDS_PER_BLOCK; 889 result += (leaf_count * 2); 890 891 /* one double indirect node block */ 892 leaf_count *= NIDS_PER_BLOCK; 893 result += leaf_count; 894 895 result <<= bits; 896 return result; 897 } 898 899 static int sanity_check_raw_super(struct super_block *sb, 900 struct f2fs_super_block *raw_super) 901 { 902 unsigned int blocksize; 903 904 if (F2FS_SUPER_MAGIC != le32_to_cpu(raw_super->magic)) { 905 f2fs_msg(sb, KERN_INFO, 906 "Magic Mismatch, valid(0x%x) - read(0x%x)", 907 F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic)); 908 return 1; 909 } 910 911 /* Currently, support only 4KB page cache size */ 912 if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) { 913 f2fs_msg(sb, KERN_INFO, 914 "Invalid page_cache_size (%lu), supports only 4KB\n", 915 PAGE_CACHE_SIZE); 916 return 1; 917 } 918 919 /* Currently, support only 4KB block size */ 920 blocksize = 1 << le32_to_cpu(raw_super->log_blocksize); 921 if (blocksize != F2FS_BLKSIZE) { 922 f2fs_msg(sb, KERN_INFO, 923 "Invalid blocksize (%u), supports only 4KB\n", 924 blocksize); 925 return 1; 926 } 927 928 /* Currently, support 512/1024/2048/4096 bytes sector size */ 929 if (le32_to_cpu(raw_super->log_sectorsize) > 930 F2FS_MAX_LOG_SECTOR_SIZE || 931 le32_to_cpu(raw_super->log_sectorsize) < 932 F2FS_MIN_LOG_SECTOR_SIZE) { 933 f2fs_msg(sb, KERN_INFO, "Invalid log sectorsize (%u)", 934 le32_to_cpu(raw_super->log_sectorsize)); 935 return 1; 936 } 937 if (le32_to_cpu(raw_super->log_sectors_per_block) + 938 le32_to_cpu(raw_super->log_sectorsize) != 939 F2FS_MAX_LOG_SECTOR_SIZE) { 940 f2fs_msg(sb, KERN_INFO, 941 "Invalid log sectors per block(%u) log sectorsize(%u)", 942 le32_to_cpu(raw_super->log_sectors_per_block), 943 le32_to_cpu(raw_super->log_sectorsize)); 944 return 1; 945 } 946 return 0; 947 } 948 949 static int sanity_check_ckpt(struct f2fs_sb_info *sbi) 950 { 951 unsigned int total, fsmeta; 952 struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi); 953 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 954 955 total = le32_to_cpu(raw_super->segment_count); 956 fsmeta = le32_to_cpu(raw_super->segment_count_ckpt); 957 fsmeta += le32_to_cpu(raw_super->segment_count_sit); 958 fsmeta += le32_to_cpu(raw_super->segment_count_nat); 959 fsmeta += le32_to_cpu(ckpt->rsvd_segment_count); 960 fsmeta += le32_to_cpu(raw_super->segment_count_ssa); 961 962 if (unlikely(fsmeta >= total)) 963 return 1; 964 965 if (unlikely(f2fs_cp_error(sbi))) { 966 f2fs_msg(sbi->sb, KERN_ERR, "A bug case: need to run fsck"); 967 return 1; 968 } 969 return 0; 970 } 971 972 static void init_sb_info(struct f2fs_sb_info *sbi) 973 { 974 struct f2fs_super_block *raw_super = sbi->raw_super; 975 int i; 976 977 sbi->log_sectors_per_block = 978 le32_to_cpu(raw_super->log_sectors_per_block); 979 sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize); 980 sbi->blocksize = 1 << sbi->log_blocksize; 981 sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg); 982 sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg; 983 sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec); 984 sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone); 985 sbi->total_sections = le32_to_cpu(raw_super->section_count); 986 sbi->total_node_count = 987 (le32_to_cpu(raw_super->segment_count_nat) / 2) 988 * sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK; 989 sbi->root_ino_num = le32_to_cpu(raw_super->root_ino); 990 sbi->node_ino_num = le32_to_cpu(raw_super->node_ino); 991 sbi->meta_ino_num = le32_to_cpu(raw_super->meta_ino); 992 sbi->cur_victim_sec = NULL_SECNO; 993 sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH; 994 995 for (i = 0; i < NR_COUNT_TYPE; i++) 996 atomic_set(&sbi->nr_pages[i], 0); 997 998 sbi->dir_level = DEF_DIR_LEVEL; 999 clear_sbi_flag(sbi, SBI_NEED_FSCK); 1000 1001 INIT_LIST_HEAD(&sbi->s_list); 1002 mutex_init(&sbi->umount_mutex); 1003 } 1004 1005 /* 1006 * Read f2fs raw super block. 1007 * Because we have two copies of super block, so read the first one at first, 1008 * if the first one is invalid, move to read the second one. 1009 */ 1010 static int read_raw_super_block(struct super_block *sb, 1011 struct f2fs_super_block **raw_super, 1012 struct buffer_head **raw_super_buf, 1013 int *recovery) 1014 { 1015 int block = 0; 1016 struct buffer_head *buffer; 1017 struct f2fs_super_block *super; 1018 int err = 0; 1019 1020 retry: 1021 buffer = sb_bread(sb, block); 1022 if (!buffer) { 1023 *recovery = 1; 1024 f2fs_msg(sb, KERN_ERR, "Unable to read %dth superblock", 1025 block + 1); 1026 if (block == 0) { 1027 block++; 1028 goto retry; 1029 } else { 1030 err = -EIO; 1031 goto out; 1032 } 1033 } 1034 1035 super = (struct f2fs_super_block *) 1036 ((char *)(buffer)->b_data + F2FS_SUPER_OFFSET); 1037 1038 /* sanity checking of raw super */ 1039 if (sanity_check_raw_super(sb, super)) { 1040 brelse(buffer); 1041 *recovery = 1; 1042 f2fs_msg(sb, KERN_ERR, 1043 "Can't find valid F2FS filesystem in %dth superblock", 1044 block + 1); 1045 if (block == 0) { 1046 block++; 1047 goto retry; 1048 } else { 1049 err = -EINVAL; 1050 goto out; 1051 } 1052 } 1053 1054 if (!*raw_super) { 1055 *raw_super_buf = buffer; 1056 *raw_super = super; 1057 } else { 1058 /* already have a valid superblock */ 1059 brelse(buffer); 1060 } 1061 1062 /* check the validity of the second superblock */ 1063 if (block == 0) { 1064 block++; 1065 goto retry; 1066 } 1067 1068 out: 1069 /* No valid superblock */ 1070 if (!*raw_super) 1071 return err; 1072 1073 return 0; 1074 } 1075 1076 int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover) 1077 { 1078 struct buffer_head *sbh = sbi->raw_super_buf; 1079 sector_t block = sbh->b_blocknr; 1080 int err; 1081 1082 /* write back-up superblock first */ 1083 sbh->b_blocknr = block ? 0 : 1; 1084 mark_buffer_dirty(sbh); 1085 err = sync_dirty_buffer(sbh); 1086 1087 sbh->b_blocknr = block; 1088 1089 /* if we are in recovery path, skip writing valid superblock */ 1090 if (recover || err) 1091 goto out; 1092 1093 /* write current valid superblock */ 1094 mark_buffer_dirty(sbh); 1095 err = sync_dirty_buffer(sbh); 1096 out: 1097 clear_buffer_write_io_error(sbh); 1098 set_buffer_uptodate(sbh); 1099 return err; 1100 } 1101 1102 static int f2fs_fill_super(struct super_block *sb, void *data, int silent) 1103 { 1104 struct f2fs_sb_info *sbi; 1105 struct f2fs_super_block *raw_super; 1106 struct buffer_head *raw_super_buf; 1107 struct inode *root; 1108 long err; 1109 bool retry = true, need_fsck = false; 1110 char *options = NULL; 1111 int recovery, i; 1112 1113 try_onemore: 1114 err = -EINVAL; 1115 raw_super = NULL; 1116 raw_super_buf = NULL; 1117 recovery = 0; 1118 1119 /* allocate memory for f2fs-specific super block info */ 1120 sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL); 1121 if (!sbi) 1122 return -ENOMEM; 1123 1124 /* set a block size */ 1125 if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) { 1126 f2fs_msg(sb, KERN_ERR, "unable to set blocksize"); 1127 goto free_sbi; 1128 } 1129 1130 err = read_raw_super_block(sb, &raw_super, &raw_super_buf, &recovery); 1131 if (err) 1132 goto free_sbi; 1133 1134 sb->s_fs_info = sbi; 1135 default_options(sbi); 1136 /* parse mount options */ 1137 options = kstrdup((const char *)data, GFP_KERNEL); 1138 if (data && !options) { 1139 err = -ENOMEM; 1140 goto free_sb_buf; 1141 } 1142 1143 err = parse_options(sb, options); 1144 if (err) 1145 goto free_options; 1146 1147 sb->s_maxbytes = max_file_size(le32_to_cpu(raw_super->log_blocksize)); 1148 sb->s_max_links = F2FS_LINK_MAX; 1149 get_random_bytes(&sbi->s_next_generation, sizeof(u32)); 1150 1151 sb->s_op = &f2fs_sops; 1152 sb->s_xattr = f2fs_xattr_handlers; 1153 sb->s_export_op = &f2fs_export_ops; 1154 sb->s_magic = F2FS_SUPER_MAGIC; 1155 sb->s_time_gran = 1; 1156 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | 1157 (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0); 1158 memcpy(sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid)); 1159 1160 /* init f2fs-specific super block info */ 1161 sbi->sb = sb; 1162 sbi->raw_super = raw_super; 1163 sbi->raw_super_buf = raw_super_buf; 1164 mutex_init(&sbi->gc_mutex); 1165 mutex_init(&sbi->writepages); 1166 mutex_init(&sbi->cp_mutex); 1167 init_rwsem(&sbi->node_write); 1168 1169 /* disallow all the data/node/meta page writes */ 1170 set_sbi_flag(sbi, SBI_POR_DOING); 1171 spin_lock_init(&sbi->stat_lock); 1172 1173 init_rwsem(&sbi->read_io.io_rwsem); 1174 sbi->read_io.sbi = sbi; 1175 sbi->read_io.bio = NULL; 1176 for (i = 0; i < NR_PAGE_TYPE; i++) { 1177 init_rwsem(&sbi->write_io[i].io_rwsem); 1178 sbi->write_io[i].sbi = sbi; 1179 sbi->write_io[i].bio = NULL; 1180 } 1181 1182 init_rwsem(&sbi->cp_rwsem); 1183 init_waitqueue_head(&sbi->cp_wait); 1184 init_sb_info(sbi); 1185 1186 /* get an inode for meta space */ 1187 sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi)); 1188 if (IS_ERR(sbi->meta_inode)) { 1189 f2fs_msg(sb, KERN_ERR, "Failed to read F2FS meta data inode"); 1190 err = PTR_ERR(sbi->meta_inode); 1191 goto free_options; 1192 } 1193 1194 err = get_valid_checkpoint(sbi); 1195 if (err) { 1196 f2fs_msg(sb, KERN_ERR, "Failed to get valid F2FS checkpoint"); 1197 goto free_meta_inode; 1198 } 1199 1200 /* sanity checking of checkpoint */ 1201 err = -EINVAL; 1202 if (sanity_check_ckpt(sbi)) { 1203 f2fs_msg(sb, KERN_ERR, "Invalid F2FS checkpoint"); 1204 goto free_cp; 1205 } 1206 1207 sbi->total_valid_node_count = 1208 le32_to_cpu(sbi->ckpt->valid_node_count); 1209 sbi->total_valid_inode_count = 1210 le32_to_cpu(sbi->ckpt->valid_inode_count); 1211 sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count); 1212 sbi->total_valid_block_count = 1213 le64_to_cpu(sbi->ckpt->valid_block_count); 1214 sbi->last_valid_block_count = sbi->total_valid_block_count; 1215 sbi->alloc_valid_block_count = 0; 1216 INIT_LIST_HEAD(&sbi->dir_inode_list); 1217 spin_lock_init(&sbi->dir_inode_lock); 1218 1219 init_extent_cache_info(sbi); 1220 1221 init_ino_entry_info(sbi); 1222 1223 /* setup f2fs internal modules */ 1224 err = build_segment_manager(sbi); 1225 if (err) { 1226 f2fs_msg(sb, KERN_ERR, 1227 "Failed to initialize F2FS segment manager"); 1228 goto free_sm; 1229 } 1230 err = build_node_manager(sbi); 1231 if (err) { 1232 f2fs_msg(sb, KERN_ERR, 1233 "Failed to initialize F2FS node manager"); 1234 goto free_nm; 1235 } 1236 1237 build_gc_manager(sbi); 1238 1239 /* get an inode for node space */ 1240 sbi->node_inode = f2fs_iget(sb, F2FS_NODE_INO(sbi)); 1241 if (IS_ERR(sbi->node_inode)) { 1242 f2fs_msg(sb, KERN_ERR, "Failed to read node inode"); 1243 err = PTR_ERR(sbi->node_inode); 1244 goto free_nm; 1245 } 1246 1247 f2fs_join_shrinker(sbi); 1248 1249 /* if there are nt orphan nodes free them */ 1250 err = recover_orphan_inodes(sbi); 1251 if (err) 1252 goto free_node_inode; 1253 1254 /* read root inode and dentry */ 1255 root = f2fs_iget(sb, F2FS_ROOT_INO(sbi)); 1256 if (IS_ERR(root)) { 1257 f2fs_msg(sb, KERN_ERR, "Failed to read root inode"); 1258 err = PTR_ERR(root); 1259 goto free_node_inode; 1260 } 1261 if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) { 1262 iput(root); 1263 err = -EINVAL; 1264 goto free_node_inode; 1265 } 1266 1267 sb->s_root = d_make_root(root); /* allocate root dentry */ 1268 if (!sb->s_root) { 1269 err = -ENOMEM; 1270 goto free_root_inode; 1271 } 1272 1273 err = f2fs_build_stats(sbi); 1274 if (err) 1275 goto free_root_inode; 1276 1277 if (f2fs_proc_root) 1278 sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root); 1279 1280 if (sbi->s_proc) 1281 proc_create_data("segment_info", S_IRUGO, sbi->s_proc, 1282 &f2fs_seq_segment_info_fops, sb); 1283 1284 sbi->s_kobj.kset = f2fs_kset; 1285 init_completion(&sbi->s_kobj_unregister); 1286 err = kobject_init_and_add(&sbi->s_kobj, &f2fs_ktype, NULL, 1287 "%s", sb->s_id); 1288 if (err) 1289 goto free_proc; 1290 1291 /* recover fsynced data */ 1292 if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) { 1293 /* 1294 * mount should be failed, when device has readonly mode, and 1295 * previous checkpoint was not done by clean system shutdown. 1296 */ 1297 if (bdev_read_only(sb->s_bdev) && 1298 !is_set_ckpt_flags(sbi->ckpt, CP_UMOUNT_FLAG)) { 1299 err = -EROFS; 1300 goto free_kobj; 1301 } 1302 1303 if (need_fsck) 1304 set_sbi_flag(sbi, SBI_NEED_FSCK); 1305 1306 err = recover_fsync_data(sbi); 1307 if (err) { 1308 need_fsck = true; 1309 f2fs_msg(sb, KERN_ERR, 1310 "Cannot recover all fsync data errno=%ld", err); 1311 goto free_kobj; 1312 } 1313 } 1314 /* recover_fsync_data() cleared this already */ 1315 clear_sbi_flag(sbi, SBI_POR_DOING); 1316 1317 /* 1318 * If filesystem is not mounted as read-only then 1319 * do start the gc_thread. 1320 */ 1321 if (test_opt(sbi, BG_GC) && !f2fs_readonly(sb)) { 1322 /* After POR, we can run background GC thread.*/ 1323 err = start_gc_thread(sbi); 1324 if (err) 1325 goto free_kobj; 1326 } 1327 kfree(options); 1328 1329 /* recover broken superblock */ 1330 if (recovery && !f2fs_readonly(sb) && !bdev_read_only(sb->s_bdev)) { 1331 f2fs_msg(sb, KERN_INFO, "Recover invalid superblock"); 1332 f2fs_commit_super(sbi, true); 1333 } 1334 1335 return 0; 1336 1337 free_kobj: 1338 kobject_del(&sbi->s_kobj); 1339 free_proc: 1340 if (sbi->s_proc) { 1341 remove_proc_entry("segment_info", sbi->s_proc); 1342 remove_proc_entry(sb->s_id, f2fs_proc_root); 1343 } 1344 f2fs_destroy_stats(sbi); 1345 free_root_inode: 1346 dput(sb->s_root); 1347 sb->s_root = NULL; 1348 free_node_inode: 1349 mutex_lock(&sbi->umount_mutex); 1350 f2fs_leave_shrinker(sbi); 1351 iput(sbi->node_inode); 1352 mutex_unlock(&sbi->umount_mutex); 1353 free_nm: 1354 destroy_node_manager(sbi); 1355 free_sm: 1356 destroy_segment_manager(sbi); 1357 free_cp: 1358 kfree(sbi->ckpt); 1359 free_meta_inode: 1360 make_bad_inode(sbi->meta_inode); 1361 iput(sbi->meta_inode); 1362 free_options: 1363 kfree(options); 1364 free_sb_buf: 1365 brelse(raw_super_buf); 1366 free_sbi: 1367 kfree(sbi); 1368 1369 /* give only one another chance */ 1370 if (retry) { 1371 retry = false; 1372 shrink_dcache_sb(sb); 1373 goto try_onemore; 1374 } 1375 return err; 1376 } 1377 1378 static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags, 1379 const char *dev_name, void *data) 1380 { 1381 return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super); 1382 } 1383 1384 static void kill_f2fs_super(struct super_block *sb) 1385 { 1386 if (sb->s_root) 1387 set_sbi_flag(F2FS_SB(sb), SBI_IS_CLOSE); 1388 kill_block_super(sb); 1389 } 1390 1391 static struct file_system_type f2fs_fs_type = { 1392 .owner = THIS_MODULE, 1393 .name = "f2fs", 1394 .mount = f2fs_mount, 1395 .kill_sb = kill_f2fs_super, 1396 .fs_flags = FS_REQUIRES_DEV, 1397 }; 1398 MODULE_ALIAS_FS("f2fs"); 1399 1400 static int __init init_inodecache(void) 1401 { 1402 f2fs_inode_cachep = f2fs_kmem_cache_create("f2fs_inode_cache", 1403 sizeof(struct f2fs_inode_info)); 1404 if (!f2fs_inode_cachep) 1405 return -ENOMEM; 1406 return 0; 1407 } 1408 1409 static void destroy_inodecache(void) 1410 { 1411 /* 1412 * Make sure all delayed rcu free inodes are flushed before we 1413 * destroy cache. 1414 */ 1415 rcu_barrier(); 1416 kmem_cache_destroy(f2fs_inode_cachep); 1417 } 1418 1419 static int __init init_f2fs_fs(void) 1420 { 1421 int err; 1422 1423 f2fs_build_trace_ios(); 1424 1425 err = init_inodecache(); 1426 if (err) 1427 goto fail; 1428 err = create_node_manager_caches(); 1429 if (err) 1430 goto free_inodecache; 1431 err = create_segment_manager_caches(); 1432 if (err) 1433 goto free_node_manager_caches; 1434 err = create_checkpoint_caches(); 1435 if (err) 1436 goto free_segment_manager_caches; 1437 err = create_extent_cache(); 1438 if (err) 1439 goto free_checkpoint_caches; 1440 f2fs_kset = kset_create_and_add("f2fs", NULL, fs_kobj); 1441 if (!f2fs_kset) { 1442 err = -ENOMEM; 1443 goto free_extent_cache; 1444 } 1445 err = f2fs_init_crypto(); 1446 if (err) 1447 goto free_kset; 1448 1449 err = register_shrinker(&f2fs_shrinker_info); 1450 if (err) 1451 goto free_crypto; 1452 1453 err = register_filesystem(&f2fs_fs_type); 1454 if (err) 1455 goto free_shrinker; 1456 f2fs_create_root_stats(); 1457 f2fs_proc_root = proc_mkdir("fs/f2fs", NULL); 1458 return 0; 1459 1460 free_shrinker: 1461 unregister_shrinker(&f2fs_shrinker_info); 1462 free_crypto: 1463 f2fs_exit_crypto(); 1464 free_kset: 1465 kset_unregister(f2fs_kset); 1466 free_extent_cache: 1467 destroy_extent_cache(); 1468 free_checkpoint_caches: 1469 destroy_checkpoint_caches(); 1470 free_segment_manager_caches: 1471 destroy_segment_manager_caches(); 1472 free_node_manager_caches: 1473 destroy_node_manager_caches(); 1474 free_inodecache: 1475 destroy_inodecache(); 1476 fail: 1477 return err; 1478 } 1479 1480 static void __exit exit_f2fs_fs(void) 1481 { 1482 remove_proc_entry("fs/f2fs", NULL); 1483 f2fs_destroy_root_stats(); 1484 unregister_shrinker(&f2fs_shrinker_info); 1485 unregister_filesystem(&f2fs_fs_type); 1486 f2fs_exit_crypto(); 1487 destroy_extent_cache(); 1488 destroy_checkpoint_caches(); 1489 destroy_segment_manager_caches(); 1490 destroy_node_manager_caches(); 1491 destroy_inodecache(); 1492 kset_unregister(f2fs_kset); 1493 f2fs_destroy_trace_ios(); 1494 } 1495 1496 module_init(init_f2fs_fs) 1497 module_exit(exit_f2fs_fs) 1498 1499 MODULE_AUTHOR("Samsung Electronics's Praesto Team"); 1500 MODULE_DESCRIPTION("Flash Friendly File System"); 1501 MODULE_LICENSE("GPL"); 1502