super.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442
  1. /*
  2. * JFFS2 -- Journalling Flash File System, Version 2.
  3. *
  4. * Copyright © 2001-2007 Red Hat, Inc.
  5. *
  6. * Created by David Woodhouse <dwmw2@infradead.org>
  7. *
  8. * For licensing information, see the file 'LICENCE' in this directory.
  9. *
  10. */
  11. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12. #include <linux/kernel.h>
  13. #include <linux/module.h>
  14. #include <linux/slab.h>
  15. #include <linux/init.h>
  16. #include <linux/list.h>
  17. #include <linux/fs.h>
  18. #include <linux/err.h>
  19. #include <linux/mount.h>
  20. #include <linux/fs_context.h>
  21. #include <linux/fs_parser.h>
  22. #include <linux/jffs2.h>
  23. #include <linux/pagemap.h>
  24. #include <linux/mtd/super.h>
  25. #include <linux/ctype.h>
  26. #include <linux/namei.h>
  27. #include <linux/seq_file.h>
  28. #include <linux/exportfs.h>
  29. #include "compr.h"
  30. #include "nodelist.h"
  31. static void jffs2_put_super(struct super_block *);
  32. static struct kmem_cache *jffs2_inode_cachep;
  33. static struct inode *jffs2_alloc_inode(struct super_block *sb)
  34. {
  35. struct jffs2_inode_info *f;
  36. f = kmem_cache_alloc(jffs2_inode_cachep, GFP_KERNEL);
  37. if (!f)
  38. return NULL;
  39. return &f->vfs_inode;
  40. }
  41. static void jffs2_free_inode(struct inode *inode)
  42. {
  43. struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
  44. kfree(f->target);
  45. kmem_cache_free(jffs2_inode_cachep, f);
  46. }
  47. static void jffs2_i_init_once(void *foo)
  48. {
  49. struct jffs2_inode_info *f = foo;
  50. mutex_init(&f->sem);
  51. inode_init_once(&f->vfs_inode);
  52. }
  53. static const char *jffs2_compr_name(unsigned int compr)
  54. {
  55. switch (compr) {
  56. case JFFS2_COMPR_MODE_NONE:
  57. return "none";
  58. #ifdef CONFIG_JFFS2_LZO
  59. case JFFS2_COMPR_MODE_FORCELZO:
  60. return "lzo";
  61. #endif
  62. #ifdef CONFIG_JFFS2_ZLIB
  63. case JFFS2_COMPR_MODE_FORCEZLIB:
  64. return "zlib";
  65. #endif
  66. default:
  67. /* should never happen; programmer error */
  68. WARN_ON(1);
  69. return "";
  70. }
  71. }
  72. static int jffs2_show_options(struct seq_file *s, struct dentry *root)
  73. {
  74. struct jffs2_sb_info *c = JFFS2_SB_INFO(root->d_sb);
  75. struct jffs2_mount_opts *opts = &c->mount_opts;
  76. if (opts->override_compr)
  77. seq_printf(s, ",compr=%s", jffs2_compr_name(opts->compr));
  78. if (opts->set_rp_size)
  79. seq_printf(s, ",rp_size=%u", opts->rp_size / 1024);
  80. return 0;
  81. }
  82. static int jffs2_sync_fs(struct super_block *sb, int wait)
  83. {
  84. struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
  85. #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
  86. if (jffs2_is_writebuffered(c))
  87. cancel_delayed_work_sync(&c->wbuf_dwork);
  88. #endif
  89. mutex_lock(&c->alloc_sem);
  90. jffs2_flush_wbuf_pad(c);
  91. mutex_unlock(&c->alloc_sem);
  92. return 0;
  93. }
  94. static struct inode *jffs2_nfs_get_inode(struct super_block *sb, uint64_t ino,
  95. uint32_t generation)
  96. {
  97. /* We don't care about i_generation. We'll destroy the flash
  98. before we start re-using inode numbers anyway. And even
  99. if that wasn't true, we'd have other problems...*/
  100. return jffs2_iget(sb, ino);
  101. }
  102. static struct dentry *jffs2_fh_to_dentry(struct super_block *sb, struct fid *fid,
  103. int fh_len, int fh_type)
  104. {
  105. return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
  106. jffs2_nfs_get_inode);
  107. }
  108. static struct dentry *jffs2_fh_to_parent(struct super_block *sb, struct fid *fid,
  109. int fh_len, int fh_type)
  110. {
  111. return generic_fh_to_parent(sb, fid, fh_len, fh_type,
  112. jffs2_nfs_get_inode);
  113. }
  114. static struct dentry *jffs2_get_parent(struct dentry *child)
  115. {
  116. struct jffs2_inode_info *f;
  117. uint32_t pino;
  118. BUG_ON(!d_is_dir(child));
  119. f = JFFS2_INODE_INFO(d_inode(child));
  120. pino = f->inocache->pino_nlink;
  121. JFFS2_DEBUG("Parent of directory ino #%u is #%u\n",
  122. f->inocache->ino, pino);
  123. return d_obtain_alias(jffs2_iget(child->d_sb, pino));
  124. }
  125. static const struct export_operations jffs2_export_ops = {
  126. .get_parent = jffs2_get_parent,
  127. .fh_to_dentry = jffs2_fh_to_dentry,
  128. .fh_to_parent = jffs2_fh_to_parent,
  129. };
  130. /*
  131. * JFFS2 mount options.
  132. *
  133. * Opt_source: The source device
  134. * Opt_override_compr: override default compressor
  135. * Opt_rp_size: size of reserved pool in KiB
  136. */
  137. enum {
  138. Opt_override_compr,
  139. Opt_rp_size,
  140. };
  141. static const struct constant_table jffs2_param_compr[] = {
  142. {"none", JFFS2_COMPR_MODE_NONE },
  143. #ifdef CONFIG_JFFS2_LZO
  144. {"lzo", JFFS2_COMPR_MODE_FORCELZO },
  145. #endif
  146. #ifdef CONFIG_JFFS2_ZLIB
  147. {"zlib", JFFS2_COMPR_MODE_FORCEZLIB },
  148. #endif
  149. {}
  150. };
  151. static const struct fs_parameter_spec jffs2_fs_parameters[] = {
  152. fsparam_enum ("compr", Opt_override_compr, jffs2_param_compr),
  153. fsparam_u32 ("rp_size", Opt_rp_size),
  154. {}
  155. };
  156. static int jffs2_parse_param(struct fs_context *fc, struct fs_parameter *param)
  157. {
  158. struct fs_parse_result result;
  159. struct jffs2_sb_info *c = fc->s_fs_info;
  160. int opt;
  161. opt = fs_parse(fc, jffs2_fs_parameters, param, &result);
  162. if (opt < 0)
  163. return opt;
  164. switch (opt) {
  165. case Opt_override_compr:
  166. c->mount_opts.compr = result.uint_32;
  167. c->mount_opts.override_compr = true;
  168. break;
  169. case Opt_rp_size:
  170. if (result.uint_32 > UINT_MAX / 1024)
  171. return invalf(fc, "jffs2: rp_size unrepresentable");
  172. c->mount_opts.rp_size = result.uint_32 * 1024;
  173. c->mount_opts.set_rp_size = true;
  174. break;
  175. default:
  176. return -EINVAL;
  177. }
  178. return 0;
  179. }
  180. static inline void jffs2_update_mount_opts(struct fs_context *fc)
  181. {
  182. struct jffs2_sb_info *new_c = fc->s_fs_info;
  183. struct jffs2_sb_info *c = JFFS2_SB_INFO(fc->root->d_sb);
  184. mutex_lock(&c->alloc_sem);
  185. if (new_c->mount_opts.override_compr) {
  186. c->mount_opts.override_compr = new_c->mount_opts.override_compr;
  187. c->mount_opts.compr = new_c->mount_opts.compr;
  188. }
  189. if (new_c->mount_opts.set_rp_size) {
  190. c->mount_opts.set_rp_size = new_c->mount_opts.set_rp_size;
  191. c->mount_opts.rp_size = new_c->mount_opts.rp_size;
  192. }
  193. mutex_unlock(&c->alloc_sem);
  194. }
  195. static int jffs2_reconfigure(struct fs_context *fc)
  196. {
  197. struct super_block *sb = fc->root->d_sb;
  198. sync_filesystem(sb);
  199. jffs2_update_mount_opts(fc);
  200. return jffs2_do_remount_fs(sb, fc);
  201. }
  202. static const struct super_operations jffs2_super_operations =
  203. {
  204. .alloc_inode = jffs2_alloc_inode,
  205. .free_inode = jffs2_free_inode,
  206. .put_super = jffs2_put_super,
  207. .statfs = jffs2_statfs,
  208. .evict_inode = jffs2_evict_inode,
  209. .dirty_inode = jffs2_dirty_inode,
  210. .show_options = jffs2_show_options,
  211. .sync_fs = jffs2_sync_fs,
  212. };
  213. /*
  214. * fill in the superblock
  215. */
  216. static int jffs2_fill_super(struct super_block *sb, struct fs_context *fc)
  217. {
  218. struct jffs2_sb_info *c = sb->s_fs_info;
  219. jffs2_dbg(1, "jffs2_get_sb_mtd():"
  220. " New superblock for device %d (\"%s\")\n",
  221. sb->s_mtd->index, sb->s_mtd->name);
  222. c->mtd = sb->s_mtd;
  223. c->os_priv = sb;
  224. if (c->mount_opts.rp_size > c->mtd->size)
  225. return invalf(fc, "jffs2: Too large reserve pool specified, max is %llu KB",
  226. c->mtd->size / 1024);
  227. /* Initialize JFFS2 superblock locks, the further initialization will
  228. * be done later */
  229. mutex_init(&c->alloc_sem);
  230. mutex_init(&c->erase_free_sem);
  231. init_waitqueue_head(&c->erase_wait);
  232. init_waitqueue_head(&c->inocache_wq);
  233. spin_lock_init(&c->erase_completion_lock);
  234. spin_lock_init(&c->inocache_lock);
  235. sb->s_op = &jffs2_super_operations;
  236. sb->s_export_op = &jffs2_export_ops;
  237. sb->s_flags = sb->s_flags | SB_NOATIME;
  238. sb->s_xattr = jffs2_xattr_handlers;
  239. #ifdef CONFIG_JFFS2_FS_POSIX_ACL
  240. sb->s_flags |= SB_POSIXACL;
  241. #endif
  242. return jffs2_do_fill_super(sb, fc);
  243. }
  244. static int jffs2_get_tree(struct fs_context *fc)
  245. {
  246. return get_tree_mtd(fc, jffs2_fill_super);
  247. }
  248. static void jffs2_free_fc(struct fs_context *fc)
  249. {
  250. kfree(fc->s_fs_info);
  251. }
  252. static const struct fs_context_operations jffs2_context_ops = {
  253. .free = jffs2_free_fc,
  254. .parse_param = jffs2_parse_param,
  255. .get_tree = jffs2_get_tree,
  256. .reconfigure = jffs2_reconfigure,
  257. };
  258. static int jffs2_init_fs_context(struct fs_context *fc)
  259. {
  260. struct jffs2_sb_info *ctx;
  261. ctx = kzalloc(sizeof(struct jffs2_sb_info), GFP_KERNEL);
  262. if (!ctx)
  263. return -ENOMEM;
  264. fc->s_fs_info = ctx;
  265. fc->ops = &jffs2_context_ops;
  266. return 0;
  267. }
  268. static void jffs2_put_super (struct super_block *sb)
  269. {
  270. struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
  271. jffs2_dbg(2, "%s()\n", __func__);
  272. mutex_lock(&c->alloc_sem);
  273. jffs2_flush_wbuf_pad(c);
  274. mutex_unlock(&c->alloc_sem);
  275. jffs2_sum_exit(c);
  276. jffs2_free_ino_caches(c);
  277. jffs2_free_raw_node_refs(c);
  278. kvfree(c->blocks);
  279. jffs2_flash_cleanup(c);
  280. kfree(c->inocache_list);
  281. jffs2_clear_xattr_subsystem(c);
  282. mtd_sync(c->mtd);
  283. jffs2_dbg(1, "%s(): returning\n", __func__);
  284. }
  285. static void jffs2_kill_sb(struct super_block *sb)
  286. {
  287. struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
  288. if (c && !sb_rdonly(sb))
  289. jffs2_stop_garbage_collect_thread(c);
  290. kill_mtd_super(sb);
  291. kfree(c);
  292. }
  293. static struct file_system_type jffs2_fs_type = {
  294. .owner = THIS_MODULE,
  295. .name = "jffs2",
  296. .init_fs_context = jffs2_init_fs_context,
  297. .parameters = jffs2_fs_parameters,
  298. .kill_sb = jffs2_kill_sb,
  299. };
  300. MODULE_ALIAS_FS("jffs2");
  301. static int __init init_jffs2_fs(void)
  302. {
  303. int ret;
  304. /* Paranoia checks for on-medium structures. If we ask GCC
  305. to pack them with __attribute__((packed)) then it _also_
  306. assumes that they're not aligned -- so it emits crappy
  307. code on some architectures. Ideally we want an attribute
  308. which means just 'no padding', without the alignment
  309. thing. But GCC doesn't have that -- we have to just
  310. hope the structs are the right sizes, instead. */
  311. BUILD_BUG_ON(sizeof(struct jffs2_unknown_node) != 12);
  312. BUILD_BUG_ON(sizeof(struct jffs2_raw_dirent) != 40);
  313. BUILD_BUG_ON(sizeof(struct jffs2_raw_inode) != 68);
  314. BUILD_BUG_ON(sizeof(struct jffs2_raw_summary) != 32);
  315. pr_info("version 2.2."
  316. #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
  317. " (NAND)"
  318. #endif
  319. #ifdef CONFIG_JFFS2_SUMMARY
  320. " (SUMMARY) "
  321. #endif
  322. " © 2001-2006 Red Hat, Inc.\n");
  323. jffs2_inode_cachep = kmem_cache_create("jffs2_i",
  324. sizeof(struct jffs2_inode_info),
  325. 0, (SLAB_RECLAIM_ACCOUNT|
  326. SLAB_MEM_SPREAD|SLAB_ACCOUNT),
  327. jffs2_i_init_once);
  328. if (!jffs2_inode_cachep) {
  329. pr_err("error: Failed to initialise inode cache\n");
  330. return -ENOMEM;
  331. }
  332. ret = jffs2_compressors_init();
  333. if (ret) {
  334. pr_err("error: Failed to initialise compressors\n");
  335. goto out;
  336. }
  337. ret = jffs2_create_slab_caches();
  338. if (ret) {
  339. pr_err("error: Failed to initialise slab caches\n");
  340. goto out_compressors;
  341. }
  342. ret = register_filesystem(&jffs2_fs_type);
  343. if (ret) {
  344. pr_err("error: Failed to register filesystem\n");
  345. goto out_slab;
  346. }
  347. return 0;
  348. out_slab:
  349. jffs2_destroy_slab_caches();
  350. out_compressors:
  351. jffs2_compressors_exit();
  352. out:
  353. kmem_cache_destroy(jffs2_inode_cachep);
  354. return ret;
  355. }
  356. static void __exit exit_jffs2_fs(void)
  357. {
  358. unregister_filesystem(&jffs2_fs_type);
  359. jffs2_destroy_slab_caches();
  360. jffs2_compressors_exit();
  361. /*
  362. * Make sure all delayed rcu free inodes are flushed before we
  363. * destroy cache.
  364. */
  365. rcu_barrier();
  366. kmem_cache_destroy(jffs2_inode_cachep);
  367. }
  368. module_init(init_jffs2_fs);
  369. module_exit(exit_jffs2_fs);
  370. MODULE_DESCRIPTION("The Journalling Flash File System, v2");
  371. MODULE_AUTHOR("Red Hat, Inc.");
  372. MODULE_LICENSE("GPL"); // Actually dual-licensed, but it doesn't matter for
  373. // the sake of this tag. It's Free Software.
  374. MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);