super.c 16 KB

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