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
12#include <linux/kernel.h>
13#include <linux/module.h>
14#include <linux/slab.h>
15#include <linux/smp_lock.h>
16#include <linux/init.h>
17#include <linux/list.h>
18#include <linux/fs.h>
19#include <linux/err.h>
20#include <linux/mount.h>
21#include <linux/jffs2.h>
22#include <linux/pagemap.h>
23#include <linux/mtd/super.h>
24#include <linux/ctype.h>
25#include <linux/namei.h>
26#include <linux/exportfs.h>
27#include "compr.h"
28#include "nodelist.h"
29
30static void jffs2_put_super(struct super_block *);
31
32static struct kmem_cache *jffs2_inode_cachep;
33
34static struct inode *jffs2_alloc_inode(struct super_block *sb)
35{
36	struct jffs2_inode_info *f;
37
38	f = kmem_cache_alloc(jffs2_inode_cachep, GFP_KERNEL);
39	if (!f)
40		return NULL;
41	return &f->vfs_inode;
42}
43
44static void jffs2_destroy_inode(struct inode *inode)
45{
46	kmem_cache_free(jffs2_inode_cachep, JFFS2_INODE_INFO(inode));
47}
48
49static void jffs2_i_init_once(void *foo)
50{
51	struct jffs2_inode_info *f = foo;
52
53	mutex_init(&f->sem);
54	inode_init_once(&f->vfs_inode);
55}
56
57static void jffs2_write_super(struct super_block *sb)
58{
59	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
60
61	lock_super(sb);
62	sb->s_dirt = 0;
63
64	if (!(sb->s_flags & MS_RDONLY)) {
65		D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
66		jffs2_flush_wbuf_gc(c, 0);
67	}
68
69	unlock_super(sb);
70}
71
72static int jffs2_sync_fs(struct super_block *sb, int wait)
73{
74	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
75
76	jffs2_write_super(sb);
77
78	mutex_lock(&c->alloc_sem);
79	jffs2_flush_wbuf_pad(c);
80	mutex_unlock(&c->alloc_sem);
81	return 0;
82}
83
84static 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
124static const struct export_operations jffs2_export_ops = {
125	.get_parent = jffs2_get_parent,
126	.fh_to_dentry = jffs2_fh_to_dentry,
127	.fh_to_parent = jffs2_fh_to_parent,
128};
129
130static const struct super_operations jffs2_super_operations =
131{
132	.alloc_inode =	jffs2_alloc_inode,
133	.destroy_inode =jffs2_destroy_inode,
134	.put_super =	jffs2_put_super,
135	.write_super =	jffs2_write_super,
136	.statfs =	jffs2_statfs,
137	.remount_fs =	jffs2_remount_fs,
138	.evict_inode =	jffs2_evict_inode,
139	.dirty_inode =	jffs2_dirty_inode,
140	.sync_fs =	jffs2_sync_fs,
141};
142
143/*
144 * fill in the superblock
145 */
146static int jffs2_fill_super(struct super_block *sb, void *data, int silent)
147{
148	struct jffs2_sb_info *c;
149
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));
153
154	c = kzalloc(sizeof(*c), GFP_KERNEL);
155	if (!c)
156		return -ENOMEM;
157
158	c->mtd = sb->s_mtd;
159	c->os_priv = sb;
160	sb->s_fs_info = c;
161
162	/* Initialize JFFS2 superblock locks, the further initialization will
163	 * be done later */
164	mutex_init(&c->alloc_sem);
165	mutex_init(&c->erase_free_sem);
166	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
171	sb->s_op = &jffs2_super_operations;
172	sb->s_export_op = &jffs2_export_ops;
173	sb->s_flags = sb->s_flags | MS_NOATIME;
174	sb->s_xattr = jffs2_xattr_handlers;
175#ifdef CONFIG_JFFS2_FS_POSIX_ACL
176	sb->s_flags |= MS_POSIXACL;
177#endif
178	return jffs2_do_fill_super(sb, data, silent);
179}
180
181static int jffs2_get_sb(struct file_system_type *fs_type,
182			int flags, const char *dev_name,
183			void *data, struct vfsmount *mnt)
184{
185	return get_sb_mtd(fs_type, flags, dev_name, data, jffs2_fill_super,
186			  mnt);
187}
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
195	lock_kernel();
196
197	if (sb->s_dirt)
198		jffs2_write_super(sb);
199
200	mutex_lock(&c->alloc_sem);
201	jffs2_flush_wbuf_pad(c);
202	mutex_unlock(&c->alloc_sem);
203
204	jffs2_sum_exit(c);
205
206	jffs2_free_ino_caches(c);
207	jffs2_free_raw_node_refs(c);
208	if (jffs2_blocks_use_vmalloc(c))
209		vfree(c->blocks);
210	else
211		kfree(c->blocks);
212	jffs2_flash_cleanup(c);
213	kfree(c->inocache_list);
214	jffs2_clear_xattr_subsystem(c);
215	if (c->mtd->sync)
216		c->mtd->sync(c->mtd);
217
218	unlock_kernel();
219
220	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);
226	if (!(sb->s_flags & MS_RDONLY))
227		jffs2_stop_garbage_collect_thread(c);
228	kill_mtd_super(sb);
229	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
243	/* 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. */
250	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);
254
255	printk(KERN_INFO "JFFS2 version 2.2."
256#ifdef CONFIG_JFFS2_FS_WRITEBUFFER
257	       " (NAND)"
258#endif
259#ifdef CONFIG_JFFS2_SUMMARY
260	       " (SUMMARY) "
261#endif
262	       " �� 2001-2006 Red Hat, Inc.\n");
263
264	jffs2_inode_cachep = kmem_cache_create("jffs2_i",
265					     sizeof(struct jffs2_inode_info),
266					     0, (SLAB_RECLAIM_ACCOUNT|
267						SLAB_MEM_SPREAD),
268					     jffs2_i_init_once);
269	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.");
312MODULE_LICENSE("GPL"); // Actually dual-licensed, but it doesn't matter for
313		       // the sake of this tag. It's Free Software.
314