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/proc_fs.h> 16 #include <linux/buffer_head.h> 17 #include <linux/backing-dev.h> 18 #include <linux/kthread.h> 19 #include <linux/parser.h> 20 #include <linux/mount.h> 21 #include <linux/seq_file.h> 22 #include <linux/random.h> 23 #include <linux/exportfs.h> 24 #include <linux/f2fs_fs.h> 25 26 #include "f2fs.h" 27 #include "node.h" 28 #include "xattr.h" 29 30 static struct kmem_cache *f2fs_inode_cachep; 31 32 enum { 33 Opt_gc_background_off, 34 Opt_disable_roll_forward, 35 Opt_discard, 36 Opt_noheap, 37 Opt_nouser_xattr, 38 Opt_noacl, 39 Opt_active_logs, 40 Opt_disable_ext_identify, 41 Opt_err, 42 }; 43 44 static match_table_t f2fs_tokens = { 45 {Opt_gc_background_off, "background_gc_off"}, 46 {Opt_disable_roll_forward, "disable_roll_forward"}, 47 {Opt_discard, "discard"}, 48 {Opt_noheap, "no_heap"}, 49 {Opt_nouser_xattr, "nouser_xattr"}, 50 {Opt_noacl, "noacl"}, 51 {Opt_active_logs, "active_logs=%u"}, 52 {Opt_disable_ext_identify, "disable_ext_identify"}, 53 {Opt_err, NULL}, 54 }; 55 56 void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...) 57 { 58 struct va_format vaf; 59 va_list args; 60 61 va_start(args, fmt); 62 vaf.fmt = fmt; 63 vaf.va = &args; 64 printk("%sF2FS-fs (%s): %pV\n", level, sb->s_id, &vaf); 65 va_end(args); 66 } 67 68 static void init_once(void *foo) 69 { 70 struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo; 71 72 inode_init_once(&fi->vfs_inode); 73 } 74 75 static struct inode *f2fs_alloc_inode(struct super_block *sb) 76 { 77 struct f2fs_inode_info *fi; 78 79 fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_NOFS | __GFP_ZERO); 80 if (!fi) 81 return NULL; 82 83 init_once((void *) fi); 84 85 /* Initilize f2fs-specific inode info */ 86 fi->vfs_inode.i_version = 1; 87 atomic_set(&fi->dirty_dents, 0); 88 fi->i_current_depth = 1; 89 fi->i_advise = 0; 90 rwlock_init(&fi->ext.ext_lock); 91 92 set_inode_flag(fi, FI_NEW_INODE); 93 94 return &fi->vfs_inode; 95 } 96 97 static void f2fs_i_callback(struct rcu_head *head) 98 { 99 struct inode *inode = container_of(head, struct inode, i_rcu); 100 kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode)); 101 } 102 103 static void f2fs_destroy_inode(struct inode *inode) 104 { 105 call_rcu(&inode->i_rcu, f2fs_i_callback); 106 } 107 108 static void f2fs_put_super(struct super_block *sb) 109 { 110 struct f2fs_sb_info *sbi = F2FS_SB(sb); 111 112 f2fs_destroy_stats(sbi); 113 stop_gc_thread(sbi); 114 115 write_checkpoint(sbi, false, true); 116 117 iput(sbi->node_inode); 118 iput(sbi->meta_inode); 119 120 /* destroy f2fs internal modules */ 121 destroy_node_manager(sbi); 122 destroy_segment_manager(sbi); 123 124 kfree(sbi->ckpt); 125 126 sb->s_fs_info = NULL; 127 brelse(sbi->raw_super_buf); 128 kfree(sbi); 129 } 130 131 int f2fs_sync_fs(struct super_block *sb, int sync) 132 { 133 struct f2fs_sb_info *sbi = F2FS_SB(sb); 134 135 if (!sbi->s_dirty && !get_pages(sbi, F2FS_DIRTY_NODES)) 136 return 0; 137 138 if (sync) 139 write_checkpoint(sbi, false, false); 140 else 141 f2fs_balance_fs(sbi); 142 143 return 0; 144 } 145 146 static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf) 147 { 148 struct super_block *sb = dentry->d_sb; 149 struct f2fs_sb_info *sbi = F2FS_SB(sb); 150 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 151 block_t total_count, user_block_count, start_count, ovp_count; 152 153 total_count = le64_to_cpu(sbi->raw_super->block_count); 154 user_block_count = sbi->user_block_count; 155 start_count = le32_to_cpu(sbi->raw_super->segment0_blkaddr); 156 ovp_count = SM_I(sbi)->ovp_segments << sbi->log_blocks_per_seg; 157 buf->f_type = F2FS_SUPER_MAGIC; 158 buf->f_bsize = sbi->blocksize; 159 160 buf->f_blocks = total_count - start_count; 161 buf->f_bfree = buf->f_blocks - valid_user_blocks(sbi) - ovp_count; 162 buf->f_bavail = user_block_count - valid_user_blocks(sbi); 163 164 buf->f_files = sbi->total_node_count; 165 buf->f_ffree = sbi->total_node_count - valid_inode_count(sbi); 166 167 buf->f_namelen = F2FS_MAX_NAME_LEN; 168 buf->f_fsid.val[0] = (u32)id; 169 buf->f_fsid.val[1] = (u32)(id >> 32); 170 171 return 0; 172 } 173 174 static int f2fs_show_options(struct seq_file *seq, struct dentry *root) 175 { 176 struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb); 177 178 if (test_opt(sbi, BG_GC)) 179 seq_puts(seq, ",background_gc_on"); 180 else 181 seq_puts(seq, ",background_gc_off"); 182 if (test_opt(sbi, DISABLE_ROLL_FORWARD)) 183 seq_puts(seq, ",disable_roll_forward"); 184 if (test_opt(sbi, DISCARD)) 185 seq_puts(seq, ",discard"); 186 if (test_opt(sbi, NOHEAP)) 187 seq_puts(seq, ",no_heap_alloc"); 188 #ifdef CONFIG_F2FS_FS_XATTR 189 if (test_opt(sbi, XATTR_USER)) 190 seq_puts(seq, ",user_xattr"); 191 else 192 seq_puts(seq, ",nouser_xattr"); 193 #endif 194 #ifdef CONFIG_F2FS_FS_POSIX_ACL 195 if (test_opt(sbi, POSIX_ACL)) 196 seq_puts(seq, ",acl"); 197 else 198 seq_puts(seq, ",noacl"); 199 #endif 200 if (test_opt(sbi, DISABLE_EXT_IDENTIFY)) 201 seq_puts(seq, ",disable_ext_indentify"); 202 203 seq_printf(seq, ",active_logs=%u", sbi->active_logs); 204 205 return 0; 206 } 207 208 static struct super_operations f2fs_sops = { 209 .alloc_inode = f2fs_alloc_inode, 210 .destroy_inode = f2fs_destroy_inode, 211 .write_inode = f2fs_write_inode, 212 .show_options = f2fs_show_options, 213 .evict_inode = f2fs_evict_inode, 214 .put_super = f2fs_put_super, 215 .sync_fs = f2fs_sync_fs, 216 .statfs = f2fs_statfs, 217 }; 218 219 static struct inode *f2fs_nfs_get_inode(struct super_block *sb, 220 u64 ino, u32 generation) 221 { 222 struct f2fs_sb_info *sbi = F2FS_SB(sb); 223 struct inode *inode; 224 225 if (ino < F2FS_ROOT_INO(sbi)) 226 return ERR_PTR(-ESTALE); 227 228 /* 229 * f2fs_iget isn't quite right if the inode is currently unallocated! 230 * However f2fs_iget currently does appropriate checks to handle stale 231 * inodes so everything is OK. 232 */ 233 inode = f2fs_iget(sb, ino); 234 if (IS_ERR(inode)) 235 return ERR_CAST(inode); 236 if (generation && inode->i_generation != generation) { 237 /* we didn't find the right inode.. */ 238 iput(inode); 239 return ERR_PTR(-ESTALE); 240 } 241 return inode; 242 } 243 244 static struct dentry *f2fs_fh_to_dentry(struct super_block *sb, struct fid *fid, 245 int fh_len, int fh_type) 246 { 247 return generic_fh_to_dentry(sb, fid, fh_len, fh_type, 248 f2fs_nfs_get_inode); 249 } 250 251 static struct dentry *f2fs_fh_to_parent(struct super_block *sb, struct fid *fid, 252 int fh_len, int fh_type) 253 { 254 return generic_fh_to_parent(sb, fid, fh_len, fh_type, 255 f2fs_nfs_get_inode); 256 } 257 258 static const struct export_operations f2fs_export_ops = { 259 .fh_to_dentry = f2fs_fh_to_dentry, 260 .fh_to_parent = f2fs_fh_to_parent, 261 .get_parent = f2fs_get_parent, 262 }; 263 264 static int parse_options(struct super_block *sb, struct f2fs_sb_info *sbi, 265 char *options) 266 { 267 substring_t args[MAX_OPT_ARGS]; 268 char *p; 269 int arg = 0; 270 271 if (!options) 272 return 0; 273 274 while ((p = strsep(&options, ",")) != NULL) { 275 int token; 276 if (!*p) 277 continue; 278 /* 279 * Initialize args struct so we know whether arg was 280 * found; some options take optional arguments. 281 */ 282 args[0].to = args[0].from = NULL; 283 token = match_token(p, f2fs_tokens, args); 284 285 switch (token) { 286 case Opt_gc_background_off: 287 clear_opt(sbi, BG_GC); 288 break; 289 case Opt_disable_roll_forward: 290 set_opt(sbi, DISABLE_ROLL_FORWARD); 291 break; 292 case Opt_discard: 293 set_opt(sbi, DISCARD); 294 break; 295 case Opt_noheap: 296 set_opt(sbi, NOHEAP); 297 break; 298 #ifdef CONFIG_F2FS_FS_XATTR 299 case Opt_nouser_xattr: 300 clear_opt(sbi, XATTR_USER); 301 break; 302 #else 303 case Opt_nouser_xattr: 304 f2fs_msg(sb, KERN_INFO, 305 "nouser_xattr options not supported"); 306 break; 307 #endif 308 #ifdef CONFIG_F2FS_FS_POSIX_ACL 309 case Opt_noacl: 310 clear_opt(sbi, POSIX_ACL); 311 break; 312 #else 313 case Opt_noacl: 314 f2fs_msg(sb, KERN_INFO, "noacl options not supported"); 315 break; 316 #endif 317 case Opt_active_logs: 318 if (args->from && match_int(args, &arg)) 319 return -EINVAL; 320 if (arg != 2 && arg != 4 && arg != NR_CURSEG_TYPE) 321 return -EINVAL; 322 sbi->active_logs = arg; 323 break; 324 case Opt_disable_ext_identify: 325 set_opt(sbi, DISABLE_EXT_IDENTIFY); 326 break; 327 default: 328 f2fs_msg(sb, KERN_ERR, 329 "Unrecognized mount option \"%s\" or missing value", 330 p); 331 return -EINVAL; 332 } 333 } 334 return 0; 335 } 336 337 static loff_t max_file_size(unsigned bits) 338 { 339 loff_t result = ADDRS_PER_INODE; 340 loff_t leaf_count = ADDRS_PER_BLOCK; 341 342 /* two direct node blocks */ 343 result += (leaf_count * 2); 344 345 /* two indirect node blocks */ 346 leaf_count *= NIDS_PER_BLOCK; 347 result += (leaf_count * 2); 348 349 /* one double indirect node block */ 350 leaf_count *= NIDS_PER_BLOCK; 351 result += leaf_count; 352 353 result <<= bits; 354 return result; 355 } 356 357 static int sanity_check_raw_super(struct super_block *sb, 358 struct f2fs_super_block *raw_super) 359 { 360 unsigned int blocksize; 361 362 if (F2FS_SUPER_MAGIC != le32_to_cpu(raw_super->magic)) { 363 f2fs_msg(sb, KERN_INFO, 364 "Magic Mismatch, valid(0x%x) - read(0x%x)", 365 F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic)); 366 return 1; 367 } 368 369 /* Currently, support only 4KB block size */ 370 blocksize = 1 << le32_to_cpu(raw_super->log_blocksize); 371 if (blocksize != PAGE_CACHE_SIZE) { 372 f2fs_msg(sb, KERN_INFO, 373 "Invalid blocksize (%u), supports only 4KB\n", 374 blocksize); 375 return 1; 376 } 377 if (le32_to_cpu(raw_super->log_sectorsize) != 378 F2FS_LOG_SECTOR_SIZE) { 379 f2fs_msg(sb, KERN_INFO, "Invalid log sectorsize"); 380 return 1; 381 } 382 if (le32_to_cpu(raw_super->log_sectors_per_block) != 383 F2FS_LOG_SECTORS_PER_BLOCK) { 384 f2fs_msg(sb, KERN_INFO, "Invalid log sectors per block"); 385 return 1; 386 } 387 return 0; 388 } 389 390 static int sanity_check_ckpt(struct f2fs_super_block *raw_super, 391 struct f2fs_checkpoint *ckpt) 392 { 393 unsigned int total, fsmeta; 394 395 total = le32_to_cpu(raw_super->segment_count); 396 fsmeta = le32_to_cpu(raw_super->segment_count_ckpt); 397 fsmeta += le32_to_cpu(raw_super->segment_count_sit); 398 fsmeta += le32_to_cpu(raw_super->segment_count_nat); 399 fsmeta += le32_to_cpu(ckpt->rsvd_segment_count); 400 fsmeta += le32_to_cpu(raw_super->segment_count_ssa); 401 402 if (fsmeta >= total) 403 return 1; 404 return 0; 405 } 406 407 static void init_sb_info(struct f2fs_sb_info *sbi) 408 { 409 struct f2fs_super_block *raw_super = sbi->raw_super; 410 int i; 411 412 sbi->log_sectors_per_block = 413 le32_to_cpu(raw_super->log_sectors_per_block); 414 sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize); 415 sbi->blocksize = 1 << sbi->log_blocksize; 416 sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg); 417 sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg; 418 sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec); 419 sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone); 420 sbi->total_sections = le32_to_cpu(raw_super->section_count); 421 sbi->total_node_count = 422 (le32_to_cpu(raw_super->segment_count_nat) / 2) 423 * sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK; 424 sbi->root_ino_num = le32_to_cpu(raw_super->root_ino); 425 sbi->node_ino_num = le32_to_cpu(raw_super->node_ino); 426 sbi->meta_ino_num = le32_to_cpu(raw_super->meta_ino); 427 428 for (i = 0; i < NR_COUNT_TYPE; i++) 429 atomic_set(&sbi->nr_pages[i], 0); 430 } 431 432 static int f2fs_fill_super(struct super_block *sb, void *data, int silent) 433 { 434 struct f2fs_sb_info *sbi; 435 struct f2fs_super_block *raw_super; 436 struct buffer_head *raw_super_buf; 437 struct inode *root; 438 long err = -EINVAL; 439 int i; 440 441 /* allocate memory for f2fs-specific super block info */ 442 sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL); 443 if (!sbi) 444 return -ENOMEM; 445 446 /* set a block size */ 447 if (!sb_set_blocksize(sb, F2FS_BLKSIZE)) { 448 f2fs_msg(sb, KERN_ERR, "unable to set blocksize"); 449 goto free_sbi; 450 } 451 452 /* read f2fs raw super block */ 453 raw_super_buf = sb_bread(sb, 0); 454 if (!raw_super_buf) { 455 err = -EIO; 456 f2fs_msg(sb, KERN_ERR, "unable to read superblock"); 457 goto free_sbi; 458 } 459 raw_super = (struct f2fs_super_block *) 460 ((char *)raw_super_buf->b_data + F2FS_SUPER_OFFSET); 461 462 /* init some FS parameters */ 463 sbi->active_logs = NR_CURSEG_TYPE; 464 465 set_opt(sbi, BG_GC); 466 467 #ifdef CONFIG_F2FS_FS_XATTR 468 set_opt(sbi, XATTR_USER); 469 #endif 470 #ifdef CONFIG_F2FS_FS_POSIX_ACL 471 set_opt(sbi, POSIX_ACL); 472 #endif 473 /* parse mount options */ 474 if (parse_options(sb, sbi, (char *)data)) 475 goto free_sb_buf; 476 477 /* sanity checking of raw super */ 478 if (sanity_check_raw_super(sb, raw_super)) { 479 f2fs_msg(sb, KERN_ERR, "Can't find a valid F2FS filesystem"); 480 goto free_sb_buf; 481 } 482 483 sb->s_maxbytes = max_file_size(le32_to_cpu(raw_super->log_blocksize)); 484 sb->s_max_links = F2FS_LINK_MAX; 485 get_random_bytes(&sbi->s_next_generation, sizeof(u32)); 486 487 sb->s_op = &f2fs_sops; 488 sb->s_xattr = f2fs_xattr_handlers; 489 sb->s_export_op = &f2fs_export_ops; 490 sb->s_magic = F2FS_SUPER_MAGIC; 491 sb->s_fs_info = sbi; 492 sb->s_time_gran = 1; 493 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | 494 (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0); 495 memcpy(sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid)); 496 497 /* init f2fs-specific super block info */ 498 sbi->sb = sb; 499 sbi->raw_super = raw_super; 500 sbi->raw_super_buf = raw_super_buf; 501 mutex_init(&sbi->gc_mutex); 502 mutex_init(&sbi->write_inode); 503 mutex_init(&sbi->writepages); 504 mutex_init(&sbi->cp_mutex); 505 for (i = 0; i < NR_LOCK_TYPE; i++) 506 mutex_init(&sbi->fs_lock[i]); 507 sbi->por_doing = 0; 508 spin_lock_init(&sbi->stat_lock); 509 init_rwsem(&sbi->bio_sem); 510 init_sb_info(sbi); 511 512 /* get an inode for meta space */ 513 sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi)); 514 if (IS_ERR(sbi->meta_inode)) { 515 f2fs_msg(sb, KERN_ERR, "Failed to read F2FS meta data inode"); 516 err = PTR_ERR(sbi->meta_inode); 517 goto free_sb_buf; 518 } 519 520 err = get_valid_checkpoint(sbi); 521 if (err) { 522 f2fs_msg(sb, KERN_ERR, "Failed to get valid F2FS checkpoint"); 523 goto free_meta_inode; 524 } 525 526 /* sanity checking of checkpoint */ 527 err = -EINVAL; 528 if (sanity_check_ckpt(raw_super, sbi->ckpt)) { 529 f2fs_msg(sb, KERN_ERR, "Invalid F2FS checkpoint"); 530 goto free_cp; 531 } 532 533 sbi->total_valid_node_count = 534 le32_to_cpu(sbi->ckpt->valid_node_count); 535 sbi->total_valid_inode_count = 536 le32_to_cpu(sbi->ckpt->valid_inode_count); 537 sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count); 538 sbi->total_valid_block_count = 539 le64_to_cpu(sbi->ckpt->valid_block_count); 540 sbi->last_valid_block_count = sbi->total_valid_block_count; 541 sbi->alloc_valid_block_count = 0; 542 INIT_LIST_HEAD(&sbi->dir_inode_list); 543 spin_lock_init(&sbi->dir_inode_lock); 544 545 init_orphan_info(sbi); 546 547 /* setup f2fs internal modules */ 548 err = build_segment_manager(sbi); 549 if (err) { 550 f2fs_msg(sb, KERN_ERR, 551 "Failed to initialize F2FS segment manager"); 552 goto free_sm; 553 } 554 err = build_node_manager(sbi); 555 if (err) { 556 f2fs_msg(sb, KERN_ERR, 557 "Failed to initialize F2FS node manager"); 558 goto free_nm; 559 } 560 561 build_gc_manager(sbi); 562 563 /* get an inode for node space */ 564 sbi->node_inode = f2fs_iget(sb, F2FS_NODE_INO(sbi)); 565 if (IS_ERR(sbi->node_inode)) { 566 f2fs_msg(sb, KERN_ERR, "Failed to read node inode"); 567 err = PTR_ERR(sbi->node_inode); 568 goto free_nm; 569 } 570 571 /* if there are nt orphan nodes free them */ 572 err = -EINVAL; 573 if (recover_orphan_inodes(sbi)) 574 goto free_node_inode; 575 576 /* read root inode and dentry */ 577 root = f2fs_iget(sb, F2FS_ROOT_INO(sbi)); 578 if (IS_ERR(root)) { 579 f2fs_msg(sb, KERN_ERR, "Failed to read root inode"); 580 err = PTR_ERR(root); 581 goto free_node_inode; 582 } 583 if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) 584 goto free_root_inode; 585 586 sb->s_root = d_make_root(root); /* allocate root dentry */ 587 if (!sb->s_root) { 588 err = -ENOMEM; 589 goto free_root_inode; 590 } 591 592 /* recover fsynced data */ 593 if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) 594 recover_fsync_data(sbi); 595 596 /* After POR, we can run background GC thread */ 597 err = start_gc_thread(sbi); 598 if (err) 599 goto fail; 600 601 err = f2fs_build_stats(sbi); 602 if (err) 603 goto fail; 604 605 return 0; 606 fail: 607 stop_gc_thread(sbi); 608 free_root_inode: 609 dput(sb->s_root); 610 sb->s_root = NULL; 611 free_node_inode: 612 iput(sbi->node_inode); 613 free_nm: 614 destroy_node_manager(sbi); 615 free_sm: 616 destroy_segment_manager(sbi); 617 free_cp: 618 kfree(sbi->ckpt); 619 free_meta_inode: 620 make_bad_inode(sbi->meta_inode); 621 iput(sbi->meta_inode); 622 free_sb_buf: 623 brelse(raw_super_buf); 624 free_sbi: 625 kfree(sbi); 626 return err; 627 } 628 629 static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags, 630 const char *dev_name, void *data) 631 { 632 return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super); 633 } 634 635 static struct file_system_type f2fs_fs_type = { 636 .owner = THIS_MODULE, 637 .name = "f2fs", 638 .mount = f2fs_mount, 639 .kill_sb = kill_block_super, 640 .fs_flags = FS_REQUIRES_DEV, 641 }; 642 643 static int __init init_inodecache(void) 644 { 645 f2fs_inode_cachep = f2fs_kmem_cache_create("f2fs_inode_cache", 646 sizeof(struct f2fs_inode_info), NULL); 647 if (f2fs_inode_cachep == NULL) 648 return -ENOMEM; 649 return 0; 650 } 651 652 static void destroy_inodecache(void) 653 { 654 /* 655 * Make sure all delayed rcu free inodes are flushed before we 656 * destroy cache. 657 */ 658 rcu_barrier(); 659 kmem_cache_destroy(f2fs_inode_cachep); 660 } 661 662 static int __init init_f2fs_fs(void) 663 { 664 int err; 665 666 err = init_inodecache(); 667 if (err) 668 goto fail; 669 err = create_node_manager_caches(); 670 if (err) 671 goto fail; 672 err = create_gc_caches(); 673 if (err) 674 goto fail; 675 err = create_checkpoint_caches(); 676 if (err) 677 goto fail; 678 err = register_filesystem(&f2fs_fs_type); 679 if (err) 680 goto fail; 681 f2fs_create_root_stats(); 682 fail: 683 return err; 684 } 685 686 static void __exit exit_f2fs_fs(void) 687 { 688 f2fs_destroy_root_stats(); 689 unregister_filesystem(&f2fs_fs_type); 690 destroy_checkpoint_caches(); 691 destroy_gc_caches(); 692 destroy_node_manager_caches(); 693 destroy_inodecache(); 694 } 695 696 module_init(init_f2fs_fs) 697 module_exit(exit_f2fs_fs) 698 699 MODULE_AUTHOR("Samsung Electronics's Praesto Team"); 700 MODULE_DESCRIPTION("Flash Friendly File System"); 701 MODULE_LICENSE("GPL"); 702