blob: 40f6e6385fd1f340d7e097ce5134b287d8d0d7e6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
David Woodhousec00c3102007-04-25 14:16:47 +01004 * Copyright © 2001-2007 Red Hat, Inc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * Created by David Woodhouse <dwmw2@infradead.org>
7 *
8 * For licensing information, see the file 'LICENCE' in this directory.
9 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 */
11
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#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>
Artem Bityutskiy9c740342006-10-11 14:52:47 +030018#include <linux/err.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/mount.h>
Andres Salomon92abc472011-10-16 18:15:16 -070020#include <linux/parser.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/jffs2.h>
22#include <linux/pagemap.h>
David Howellsacaebfd2007-05-10 22:51:50 -070023#include <linux/mtd/super.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/ctype.h>
25#include <linux/namei.h>
Andres Salomon92abc472011-10-16 18:15:16 -070026#include <linux/seq_file.h>
David Woodhouse5f556aa2008-07-31 20:39:25 +010027#include <linux/exportfs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include "compr.h"
29#include "nodelist.h"
30
31static void jffs2_put_super(struct super_block *);
32
Christoph Lametere18b8902006-12-06 20:33:20 -080033static struct kmem_cache *jffs2_inode_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
35static struct inode *jffs2_alloc_inode(struct super_block *sb)
36{
David Woodhouse4e571ab2008-05-01 12:28:04 +010037 struct jffs2_inode_info *f;
38
39 f = kmem_cache_alloc(jffs2_inode_cachep, GFP_KERNEL);
40 if (!f)
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 return NULL;
David Woodhouse4e571ab2008-05-01 12:28:04 +010042 return &f->vfs_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070043}
44
Nick Pigginfa0d7e32011-01-07 17:49:49 +110045static void jffs2_i_callback(struct rcu_head *head)
46{
47 struct inode *inode = container_of(head, struct inode, i_rcu);
48 INIT_LIST_HEAD(&inode->i_dentry);
49 kmem_cache_free(jffs2_inode_cachep, JFFS2_INODE_INFO(inode));
50}
51
Linus Torvalds1da177e2005-04-16 15:20:36 -070052static void jffs2_destroy_inode(struct inode *inode)
53{
Nick Pigginfa0d7e32011-01-07 17:49:49 +110054 call_rcu(&inode->i_rcu, jffs2_i_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055}
56
Alexey Dobriyan51cc5062008-07-25 19:45:34 -070057static void jffs2_i_init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058{
David Woodhouse4e571ab2008-05-01 12:28:04 +010059 struct jffs2_inode_info *f = foo;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
David Woodhouse4e571ab2008-05-01 12:28:04 +010061 mutex_init(&f->sem);
62 inode_init_once(&f->vfs_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063}
64
Christoph Hellwig01ba6872009-05-11 23:34:27 +020065static void jffs2_write_super(struct super_block *sb)
66{
67 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
Christoph Hellwigebc1ac12009-05-11 23:35:03 +020068
69 lock_super(sb);
Christoph Hellwig01ba6872009-05-11 23:34:27 +020070 sb->s_dirt = 0;
71
Christoph Hellwigebc1ac12009-05-11 23:35:03 +020072 if (!(sb->s_flags & MS_RDONLY)) {
73 D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
Christoph Hellwigebc1ac12009-05-11 23:35:03 +020074 jffs2_flush_wbuf_gc(c, 0);
75 }
Christoph Hellwig01ba6872009-05-11 23:34:27 +020076
Christoph Hellwigebc1ac12009-05-11 23:35:03 +020077 unlock_super(sb);
Christoph Hellwig01ba6872009-05-11 23:34:27 +020078}
79
Andres Salomon92abc472011-10-16 18:15:16 -070080static const char *jffs2_compr_name(unsigned int compr)
81{
82 switch (compr) {
83 case JFFS2_COMPR_MODE_NONE:
84 return "none";
85 default:
86 /* should never happen; programmer error */
87 WARN_ON(1);
88 return "";
89 }
90}
91
92static int jffs2_show_options(struct seq_file *s, struct vfsmount *mnt)
93{
94 struct jffs2_sb_info *c = JFFS2_SB_INFO(mnt->mnt_sb);
95 struct jffs2_mount_opts *opts = &c->mount_opts;
96
97 if (opts->override_compr)
98 seq_printf(s, ",compr=%s", jffs2_compr_name(opts->compr));
99
100 return 0;
101}
102
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103static int jffs2_sync_fs(struct super_block *sb, int wait)
104{
105 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
106
Christoph Hellwigd579ed02009-06-08 10:08:21 +0200107 jffs2_write_super(sb);
108
David Woodhouseced22072008-04-22 15:13:40 +0100109 mutex_lock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 jffs2_flush_wbuf_pad(c);
David Woodhouseced22072008-04-22 15:13:40 +0100111 mutex_unlock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 return 0;
113}
114
David Woodhouse5f556aa2008-07-31 20:39:25 +0100115static struct inode *jffs2_nfs_get_inode(struct super_block *sb, uint64_t ino,
116 uint32_t generation)
117{
118 /* We don't care about i_generation. We'll destroy the flash
119 before we start re-using inode numbers anyway. And even
120 if that wasn't true, we'd have other problems...*/
121 return jffs2_iget(sb, ino);
122}
123
124static struct dentry *jffs2_fh_to_dentry(struct super_block *sb, struct fid *fid,
125 int fh_len, int fh_type)
126{
127 return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
128 jffs2_nfs_get_inode);
129}
130
131static struct dentry *jffs2_fh_to_parent(struct super_block *sb, struct fid *fid,
132 int fh_len, int fh_type)
133{
134 return generic_fh_to_parent(sb, fid, fh_len, fh_type,
135 jffs2_nfs_get_inode);
136}
137
138static struct dentry *jffs2_get_parent(struct dentry *child)
139{
140 struct jffs2_inode_info *f;
141 uint32_t pino;
142
143 BUG_ON(!S_ISDIR(child->d_inode->i_mode));
144
145 f = JFFS2_INODE_INFO(child->d_inode);
146
147 pino = f->inocache->pino_nlink;
148
149 JFFS2_DEBUG("Parent of directory ino #%u is #%u\n",
150 f->inocache->ino, pino);
151
152 return d_obtain_alias(jffs2_iget(child->d_inode->i_sb, pino));
153}
154
Alexey Dobriyanac4cfdd2009-09-21 17:01:10 -0700155static const struct export_operations jffs2_export_ops = {
David Woodhouse5f556aa2008-07-31 20:39:25 +0100156 .get_parent = jffs2_get_parent,
157 .fh_to_dentry = jffs2_fh_to_dentry,
158 .fh_to_parent = jffs2_fh_to_parent,
159};
160
Andres Salomon92abc472011-10-16 18:15:16 -0700161/*
162 * JFFS2 mount options.
163 *
164 * Opt_override_compr: override default compressor
165 * Opt_err: just end of array marker
166 */
167enum {
168 Opt_override_compr,
169 Opt_err,
170};
171
172static const match_table_t tokens = {
173 {Opt_override_compr, "compr=%s"},
174 {Opt_err, NULL},
175};
176
177static int jffs2_parse_options(struct jffs2_sb_info *c, char *data)
178{
179 substring_t args[MAX_OPT_ARGS];
180 char *p, *name;
181
182 if (!data)
183 return 0;
184
185 while ((p = strsep(&data, ","))) {
186 int token;
187
188 if (!*p)
189 continue;
190
191 token = match_token(p, tokens, args);
192 switch (token) {
193 case Opt_override_compr:
194 name = match_strdup(&args[0]);
195
196 if (!name)
197 return -ENOMEM;
198 if (!strcmp(name, "none")) {
199 c->mount_opts.compr = JFFS2_COMPR_MODE_NONE;
200 c->mount_opts.override_compr = true;
201 }
202 kfree(name);
203 break;
204 default:
205 printk(KERN_ERR "JFFS2 Error: unrecognized mount option '%s' or missing value\n",
206 p);
207 return -EINVAL;
208 }
209 }
210
211 return 0;
212}
213
214static int jffs2_remount_fs(struct super_block *sb, int *flags, char *data)
215{
216 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
217 int err;
218
219 err = jffs2_parse_options(c, data);
220 if (err)
221 return -EINVAL;
222
223 return jffs2_do_remount_fs(sb, flags, data);
224}
225
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800226static const struct super_operations jffs2_super_operations =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227{
228 .alloc_inode = jffs2_alloc_inode,
229 .destroy_inode =jffs2_destroy_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 .put_super = jffs2_put_super,
231 .write_super = jffs2_write_super,
232 .statfs = jffs2_statfs,
233 .remount_fs = jffs2_remount_fs,
Al Virob57922d2010-06-07 14:34:48 -0400234 .evict_inode = jffs2_evict_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 .dirty_inode = jffs2_dirty_inode,
Andres Salomon92abc472011-10-16 18:15:16 -0700236 .show_options = jffs2_show_options,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 .sync_fs = jffs2_sync_fs,
238};
239
David Howellsacaebfd2007-05-10 22:51:50 -0700240/*
241 * fill in the superblock
242 */
243static int jffs2_fill_super(struct super_block *sb, void *data, int silent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 struct jffs2_sb_info *c;
Jan Blunckdb719222010-08-15 22:51:10 +0200246 int ret;
247
David Howellsacaebfd2007-05-10 22:51:50 -0700248 D1(printk(KERN_DEBUG "jffs2_get_sb_mtd():"
249 " New superblock for device %d (\"%s\")\n",
250 sb->s_mtd->index, sb->s_mtd->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
Panagiotis Issarisf8314dc2006-09-27 01:49:37 -0700252 c = kzalloc(sizeof(*c), GFP_KERNEL);
Arnd Bergmann1a028dd2010-09-16 16:11:09 +0200253 if (!c)
David Howells454e2392006-06-23 02:02:57 -0700254 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
David Howellsacaebfd2007-05-10 22:51:50 -0700256 c->mtd = sb->s_mtd;
257 c->os_priv = sb;
258 sb->s_fs_info = c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Andres Salomon92abc472011-10-16 18:15:16 -0700260 ret = jffs2_parse_options(c, data);
261 if (ret) {
262 kfree(c);
263 return -EINVAL;
264 }
265
David Howellsacaebfd2007-05-10 22:51:50 -0700266 /* Initialize JFFS2 superblock locks, the further initialization will
267 * be done later */
David Woodhouseced22072008-04-22 15:13:40 +0100268 mutex_init(&c->alloc_sem);
269 mutex_init(&c->erase_free_sem);
Artem B. Bityuckiyb6220592005-07-12 17:37:12 +0100270 init_waitqueue_head(&c->erase_wait);
271 init_waitqueue_head(&c->inocache_wq);
272 spin_lock_init(&c->erase_completion_lock);
273 spin_lock_init(&c->inocache_lock);
274
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 sb->s_op = &jffs2_super_operations;
David Woodhouse5f556aa2008-07-31 20:39:25 +0100276 sb->s_export_op = &jffs2_export_ops;
David Howellsacaebfd2007-05-10 22:51:50 -0700277 sb->s_flags = sb->s_flags | MS_NOATIME;
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900278 sb->s_xattr = jffs2_xattr_handlers;
279#ifdef CONFIG_JFFS2_FS_POSIX_ACL
280 sb->s_flags |= MS_POSIXACL;
281#endif
Jan Blunckdb719222010-08-15 22:51:10 +0200282 ret = jffs2_do_fill_super(sb, data, silent);
Jan Blunckdb719222010-08-15 22:51:10 +0200283 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284}
285
Al Viro848b83a2010-07-25 00:56:46 +0400286static struct dentry *jffs2_mount(struct file_system_type *fs_type,
David Howells454e2392006-06-23 02:02:57 -0700287 int flags, const char *dev_name,
Al Viro848b83a2010-07-25 00:56:46 +0400288 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289{
Al Viro848b83a2010-07-25 00:56:46 +0400290 return mount_mtd(fs_type, flags, dev_name, data, jffs2_fill_super);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291}
292
293static void jffs2_put_super (struct super_block *sb)
294{
295 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
296
297 D2(printk(KERN_DEBUG "jffs2: jffs2_put_super()\n"));
298
Christoph Hellwig8c85e122009-04-28 18:00:26 +0200299 if (sb->s_dirt)
300 jffs2_write_super(sb);
301
David Woodhouseced22072008-04-22 15:13:40 +0100302 mutex_lock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 jffs2_flush_wbuf_pad(c);
David Woodhouseced22072008-04-22 15:13:40 +0100304 mutex_unlock(&c->alloc_sem);
Ferenc Havasie631ddb2005-09-07 09:35:26 +0100305
306 jffs2_sum_exit(c);
307
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 jffs2_free_ino_caches(c);
309 jffs2_free_raw_node_refs(c);
Ferenc Havasi4ce1f562005-08-31 14:51:04 +0100310 if (jffs2_blocks_use_vmalloc(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 vfree(c->blocks);
312 else
313 kfree(c->blocks);
314 jffs2_flash_cleanup(c);
315 kfree(c->inocache_list);
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900316 jffs2_clear_xattr_subsystem(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 if (c->mtd->sync)
318 c->mtd->sync(c->mtd);
319
320 D1(printk(KERN_DEBUG "jffs2_put_super returning\n"));
321}
322
323static void jffs2_kill_sb(struct super_block *sb)
324{
325 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
Artem B. Bityuckiya69dde92005-05-18 12:37:28 +0100326 if (!(sb->s_flags & MS_RDONLY))
327 jffs2_stop_garbage_collect_thread(c);
David Howellsacaebfd2007-05-10 22:51:50 -0700328 kill_mtd_super(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 kfree(c);
330}
331
332static struct file_system_type jffs2_fs_type = {
333 .owner = THIS_MODULE,
334 .name = "jffs2",
Al Viro848b83a2010-07-25 00:56:46 +0400335 .mount = jffs2_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 .kill_sb = jffs2_kill_sb,
337};
338
339static int __init init_jffs2_fs(void)
340{
341 int ret;
342
David Woodhouse3e68fbb2006-05-15 00:49:43 +0100343 /* Paranoia checks for on-medium structures. If we ask GCC
344 to pack them with __attribute__((packed)) then it _also_
345 assumes that they're not aligned -- so it emits crappy
346 code on some architectures. Ideally we want an attribute
347 which means just 'no padding', without the alignment
348 thing. But GCC doesn't have that -- we have to just
349 hope the structs are the right sizes, instead. */
Alexey Dobriyan2ecd05a2006-10-11 01:22:05 -0700350 BUILD_BUG_ON(sizeof(struct jffs2_unknown_node) != 12);
351 BUILD_BUG_ON(sizeof(struct jffs2_raw_dirent) != 40);
352 BUILD_BUG_ON(sizeof(struct jffs2_raw_inode) != 68);
353 BUILD_BUG_ON(sizeof(struct jffs2_raw_summary) != 32);
David Woodhouse3e68fbb2006-05-15 00:49:43 +0100354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 printk(KERN_INFO "JFFS2 version 2.2."
Andrew Victor2f82ce12005-02-09 09:24:26 +0000356#ifdef CONFIG_JFFS2_FS_WRITEBUFFER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 " (NAND)"
358#endif
Ferenc Havasie631ddb2005-09-07 09:35:26 +0100359#ifdef CONFIG_JFFS2_SUMMARY
360 " (SUMMARY) "
361#endif
David Woodhousec00c3102007-04-25 14:16:47 +0100362 " © 2001-2006 Red Hat, Inc.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
364 jffs2_inode_cachep = kmem_cache_create("jffs2_i",
365 sizeof(struct jffs2_inode_info),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800366 0, (SLAB_RECLAIM_ACCOUNT|
367 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900368 jffs2_i_init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 if (!jffs2_inode_cachep) {
370 printk(KERN_ERR "JFFS2 error: Failed to initialise inode cache\n");
371 return -ENOMEM;
372 }
373 ret = jffs2_compressors_init();
374 if (ret) {
375 printk(KERN_ERR "JFFS2 error: Failed to initialise compressors\n");
376 goto out;
377 }
378 ret = jffs2_create_slab_caches();
379 if (ret) {
380 printk(KERN_ERR "JFFS2 error: Failed to initialise slab caches\n");
381 goto out_compressors;
382 }
383 ret = register_filesystem(&jffs2_fs_type);
384 if (ret) {
385 printk(KERN_ERR "JFFS2 error: Failed to register filesystem\n");
386 goto out_slab;
387 }
388 return 0;
389
390 out_slab:
391 jffs2_destroy_slab_caches();
392 out_compressors:
393 jffs2_compressors_exit();
394 out:
395 kmem_cache_destroy(jffs2_inode_cachep);
396 return ret;
397}
398
399static void __exit exit_jffs2_fs(void)
400{
401 unregister_filesystem(&jffs2_fs_type);
402 jffs2_destroy_slab_caches();
403 jffs2_compressors_exit();
404 kmem_cache_destroy(jffs2_inode_cachep);
405}
406
407module_init(init_jffs2_fs);
408module_exit(exit_jffs2_fs);
409
410MODULE_DESCRIPTION("The Journalling Flash File System, v2");
411MODULE_AUTHOR("Red Hat, Inc.");
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000412MODULE_LICENSE("GPL"); // Actually dual-licensed, but it doesn't matter for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 // the sake of this tag. It's Free Software.