blob: 511e2d609d129f6171bf18bdbe5c9c8c09123d12 [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>
Alexey Dobriyan405f5572009-07-11 22:08:37 +040015#include <linux/smp_lock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/init.h>
17#include <linux/list.h>
18#include <linux/fs.h>
Artem Bityutskiy9c740342006-10-11 14:52:47 +030019#include <linux/err.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/mount.h>
21#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>
David Woodhouse5f556aa2008-07-31 20:39:25 +010026#include <linux/exportfs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "compr.h"
28#include "nodelist.h"
29
30static void jffs2_put_super(struct super_block *);
31
Christoph Lametere18b8902006-12-06 20:33:20 -080032static struct kmem_cache *jffs2_inode_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
34static struct inode *jffs2_alloc_inode(struct super_block *sb)
35{
David Woodhouse4e571ab2008-05-01 12:28:04 +010036 struct jffs2_inode_info *f;
37
38 f = kmem_cache_alloc(jffs2_inode_cachep, GFP_KERNEL);
39 if (!f)
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 return NULL;
David Woodhouse4e571ab2008-05-01 12:28:04 +010041 return &f->vfs_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070042}
43
44static void jffs2_destroy_inode(struct inode *inode)
45{
46 kmem_cache_free(jffs2_inode_cachep, JFFS2_INODE_INFO(inode));
47}
48
Alexey Dobriyan51cc5062008-07-25 19:45:34 -070049static void jffs2_i_init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -070050{
David Woodhouse4e571ab2008-05-01 12:28:04 +010051 struct jffs2_inode_info *f = foo;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
David Woodhouse4e571ab2008-05-01 12:28:04 +010053 mutex_init(&f->sem);
54 inode_init_once(&f->vfs_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055}
56
Christoph Hellwig01ba6872009-05-11 23:34:27 +020057static void jffs2_write_super(struct super_block *sb)
58{
59 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
Christoph Hellwigebc1ac12009-05-11 23:35:03 +020060
61 lock_super(sb);
Christoph Hellwig01ba6872009-05-11 23:34:27 +020062 sb->s_dirt = 0;
63
Christoph Hellwigebc1ac12009-05-11 23:35:03 +020064 if (!(sb->s_flags & MS_RDONLY)) {
65 D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
Christoph Hellwigebc1ac12009-05-11 23:35:03 +020066 jffs2_flush_wbuf_gc(c, 0);
67 }
Christoph Hellwig01ba6872009-05-11 23:34:27 +020068
Christoph Hellwigebc1ac12009-05-11 23:35:03 +020069 unlock_super(sb);
Christoph Hellwig01ba6872009-05-11 23:34:27 +020070}
71
Linus Torvalds1da177e2005-04-16 15:20:36 -070072static int jffs2_sync_fs(struct super_block *sb, int wait)
73{
74 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
75
Christoph Hellwigd579ed02009-06-08 10:08:21 +020076 jffs2_write_super(sb);
77
David Woodhouseced22072008-04-22 15:13:40 +010078 mutex_lock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 jffs2_flush_wbuf_pad(c);
David Woodhouseced22072008-04-22 15:13:40 +010080 mutex_unlock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 return 0;
82}
83
David Woodhouse5f556aa2008-07-31 20:39:25 +010084static struct inode *jffs2_nfs_get_inode(struct super_block *sb, uint64_t ino,
85 uint32_t generation)
86{
87 /* We don't care about i_generation. We'll destroy the flash
88 before we start re-using inode numbers anyway. And even
89 if that wasn't true, we'd have other problems...*/
90 return jffs2_iget(sb, ino);
91}
92
93static struct dentry *jffs2_fh_to_dentry(struct super_block *sb, struct fid *fid,
94 int fh_len, int fh_type)
95{
96 return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
97 jffs2_nfs_get_inode);
98}
99
100static struct dentry *jffs2_fh_to_parent(struct super_block *sb, struct fid *fid,
101 int fh_len, int fh_type)
102{
103 return generic_fh_to_parent(sb, fid, fh_len, fh_type,
104 jffs2_nfs_get_inode);
105}
106
107static struct dentry *jffs2_get_parent(struct dentry *child)
108{
109 struct jffs2_inode_info *f;
110 uint32_t pino;
111
112 BUG_ON(!S_ISDIR(child->d_inode->i_mode));
113
114 f = JFFS2_INODE_INFO(child->d_inode);
115
116 pino = f->inocache->pino_nlink;
117
118 JFFS2_DEBUG("Parent of directory ino #%u is #%u\n",
119 f->inocache->ino, pino);
120
121 return d_obtain_alias(jffs2_iget(child->d_inode->i_sb, pino));
122}
123
Alexey Dobriyanac4cfdd2009-09-21 17:01:10 -0700124static const struct export_operations jffs2_export_ops = {
David Woodhouse5f556aa2008-07-31 20:39:25 +0100125 .get_parent = jffs2_get_parent,
126 .fh_to_dentry = jffs2_fh_to_dentry,
127 .fh_to_parent = jffs2_fh_to_parent,
128};
129
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800130static const struct super_operations jffs2_super_operations =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131{
132 .alloc_inode = jffs2_alloc_inode,
133 .destroy_inode =jffs2_destroy_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 .put_super = jffs2_put_super,
135 .write_super = jffs2_write_super,
136 .statfs = jffs2_statfs,
137 .remount_fs = jffs2_remount_fs,
138 .clear_inode = jffs2_clear_inode,
139 .dirty_inode = jffs2_dirty_inode,
140 .sync_fs = jffs2_sync_fs,
141};
142
David Howellsacaebfd2007-05-10 22:51:50 -0700143/*
144 * fill in the superblock
145 */
146static int jffs2_fill_super(struct super_block *sb, void *data, int silent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 struct jffs2_sb_info *c;
David Howellsacaebfd2007-05-10 22:51:50 -0700149
150 D1(printk(KERN_DEBUG "jffs2_get_sb_mtd():"
151 " New superblock for device %d (\"%s\")\n",
152 sb->s_mtd->index, sb->s_mtd->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
Panagiotis Issarisf8314dc2006-09-27 01:49:37 -0700154 c = kzalloc(sizeof(*c), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 if (!c)
David Howells454e2392006-06-23 02:02:57 -0700156 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
David Howellsacaebfd2007-05-10 22:51:50 -0700158 c->mtd = sb->s_mtd;
159 c->os_priv = sb;
160 sb->s_fs_info = c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
David Howellsacaebfd2007-05-10 22:51:50 -0700162 /* Initialize JFFS2 superblock locks, the further initialization will
163 * be done later */
David Woodhouseced22072008-04-22 15:13:40 +0100164 mutex_init(&c->alloc_sem);
165 mutex_init(&c->erase_free_sem);
Artem B. Bityuckiyb6220592005-07-12 17:37:12 +0100166 init_waitqueue_head(&c->erase_wait);
167 init_waitqueue_head(&c->inocache_wq);
168 spin_lock_init(&c->erase_completion_lock);
169 spin_lock_init(&c->inocache_lock);
170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 sb->s_op = &jffs2_super_operations;
David Woodhouse5f556aa2008-07-31 20:39:25 +0100172 sb->s_export_op = &jffs2_export_ops;
David Howellsacaebfd2007-05-10 22:51:50 -0700173 sb->s_flags = sb->s_flags | MS_NOATIME;
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900174 sb->s_xattr = jffs2_xattr_handlers;
175#ifdef CONFIG_JFFS2_FS_POSIX_ACL
176 sb->s_flags |= MS_POSIXACL;
177#endif
David Howellsacaebfd2007-05-10 22:51:50 -0700178 return jffs2_do_fill_super(sb, data, silent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179}
180
David Howells454e2392006-06-23 02:02:57 -0700181static int jffs2_get_sb(struct file_system_type *fs_type,
182 int flags, const char *dev_name,
183 void *data, struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184{
David Howellsacaebfd2007-05-10 22:51:50 -0700185 return get_sb_mtd(fs_type, flags, dev_name, data, jffs2_fill_super,
186 mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187}
188
189static void jffs2_put_super (struct super_block *sb)
190{
191 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
192
193 D2(printk(KERN_DEBUG "jffs2: jffs2_put_super()\n"));
194
Christoph Hellwig6cfd0142009-05-05 15:40:36 +0200195 lock_kernel();
196
Christoph Hellwig8c85e122009-04-28 18:00:26 +0200197 if (sb->s_dirt)
198 jffs2_write_super(sb);
199
David Woodhouseced22072008-04-22 15:13:40 +0100200 mutex_lock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 jffs2_flush_wbuf_pad(c);
David Woodhouseced22072008-04-22 15:13:40 +0100202 mutex_unlock(&c->alloc_sem);
Ferenc Havasie631ddb2005-09-07 09:35:26 +0100203
204 jffs2_sum_exit(c);
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 jffs2_free_ino_caches(c);
207 jffs2_free_raw_node_refs(c);
Ferenc Havasi4ce1f562005-08-31 14:51:04 +0100208 if (jffs2_blocks_use_vmalloc(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 vfree(c->blocks);
210 else
211 kfree(c->blocks);
212 jffs2_flash_cleanup(c);
213 kfree(c->inocache_list);
KaiGai Koheiaa98d7c2006-05-13 15:09:47 +0900214 jffs2_clear_xattr_subsystem(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 if (c->mtd->sync)
216 c->mtd->sync(c->mtd);
217
Christoph Hellwig6cfd0142009-05-05 15:40:36 +0200218 unlock_kernel();
219
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 D1(printk(KERN_DEBUG "jffs2_put_super returning\n"));
221}
222
223static void jffs2_kill_sb(struct super_block *sb)
224{
225 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
Artem B. Bityuckiya69dde92005-05-18 12:37:28 +0100226 if (!(sb->s_flags & MS_RDONLY))
227 jffs2_stop_garbage_collect_thread(c);
David Howellsacaebfd2007-05-10 22:51:50 -0700228 kill_mtd_super(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 kfree(c);
230}
231
232static struct file_system_type jffs2_fs_type = {
233 .owner = THIS_MODULE,
234 .name = "jffs2",
235 .get_sb = jffs2_get_sb,
236 .kill_sb = jffs2_kill_sb,
237};
238
239static int __init init_jffs2_fs(void)
240{
241 int ret;
242
David Woodhouse3e68fbb2006-05-15 00:49:43 +0100243 /* Paranoia checks for on-medium structures. If we ask GCC
244 to pack them with __attribute__((packed)) then it _also_
245 assumes that they're not aligned -- so it emits crappy
246 code on some architectures. Ideally we want an attribute
247 which means just 'no padding', without the alignment
248 thing. But GCC doesn't have that -- we have to just
249 hope the structs are the right sizes, instead. */
Alexey Dobriyan2ecd05a2006-10-11 01:22:05 -0700250 BUILD_BUG_ON(sizeof(struct jffs2_unknown_node) != 12);
251 BUILD_BUG_ON(sizeof(struct jffs2_raw_dirent) != 40);
252 BUILD_BUG_ON(sizeof(struct jffs2_raw_inode) != 68);
253 BUILD_BUG_ON(sizeof(struct jffs2_raw_summary) != 32);
David Woodhouse3e68fbb2006-05-15 00:49:43 +0100254
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 printk(KERN_INFO "JFFS2 version 2.2."
Andrew Victor2f82ce12005-02-09 09:24:26 +0000256#ifdef CONFIG_JFFS2_FS_WRITEBUFFER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 " (NAND)"
258#endif
Ferenc Havasie631ddb2005-09-07 09:35:26 +0100259#ifdef CONFIG_JFFS2_SUMMARY
260 " (SUMMARY) "
261#endif
David Woodhousec00c3102007-04-25 14:16:47 +0100262 " © 2001-2006 Red Hat, Inc.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264 jffs2_inode_cachep = kmem_cache_create("jffs2_i",
265 sizeof(struct jffs2_inode_info),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800266 0, (SLAB_RECLAIM_ACCOUNT|
267 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900268 jffs2_i_init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 if (!jffs2_inode_cachep) {
270 printk(KERN_ERR "JFFS2 error: Failed to initialise inode cache\n");
271 return -ENOMEM;
272 }
273 ret = jffs2_compressors_init();
274 if (ret) {
275 printk(KERN_ERR "JFFS2 error: Failed to initialise compressors\n");
276 goto out;
277 }
278 ret = jffs2_create_slab_caches();
279 if (ret) {
280 printk(KERN_ERR "JFFS2 error: Failed to initialise slab caches\n");
281 goto out_compressors;
282 }
283 ret = register_filesystem(&jffs2_fs_type);
284 if (ret) {
285 printk(KERN_ERR "JFFS2 error: Failed to register filesystem\n");
286 goto out_slab;
287 }
288 return 0;
289
290 out_slab:
291 jffs2_destroy_slab_caches();
292 out_compressors:
293 jffs2_compressors_exit();
294 out:
295 kmem_cache_destroy(jffs2_inode_cachep);
296 return ret;
297}
298
299static void __exit exit_jffs2_fs(void)
300{
301 unregister_filesystem(&jffs2_fs_type);
302 jffs2_destroy_slab_caches();
303 jffs2_compressors_exit();
304 kmem_cache_destroy(jffs2_inode_cachep);
305}
306
307module_init(init_jffs2_fs);
308module_exit(exit_jffs2_fs);
309
310MODULE_DESCRIPTION("The Journalling Flash File System, v2");
311MODULE_AUTHOR("Red Hat, Inc.");
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000312MODULE_LICENSE("GPL"); // Actually dual-licensed, but it doesn't matter for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 // the sake of this tag. It's Free Software.