xref: /openbmc/linux/fs/jffs2/super.c (revision b6dcefde)
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 
30 static void jffs2_put_super(struct super_block *);
31 
32 static struct kmem_cache *jffs2_inode_cachep;
33 
34 static 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 
44 static void jffs2_destroy_inode(struct inode *inode)
45 {
46 	kmem_cache_free(jffs2_inode_cachep, JFFS2_INODE_INFO(inode));
47 }
48 
49 static 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 
57 static 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_garbage_collect_trigger(c);
67 		jffs2_erase_pending_blocks(c, 0);
68 		jffs2_flush_wbuf_gc(c, 0);
69 	}
70 
71 	unlock_super(sb);
72 }
73 
74 static int jffs2_sync_fs(struct super_block *sb, int wait)
75 {
76 	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
77 
78 	jffs2_write_super(sb);
79 
80 	mutex_lock(&c->alloc_sem);
81 	jffs2_flush_wbuf_pad(c);
82 	mutex_unlock(&c->alloc_sem);
83 	return 0;
84 }
85 
86 static struct inode *jffs2_nfs_get_inode(struct super_block *sb, uint64_t ino,
87 					 uint32_t generation)
88 {
89 	/* We don't care about i_generation. We'll destroy the flash
90 	   before we start re-using inode numbers anyway. And even
91 	   if that wasn't true, we'd have other problems...*/
92 	return jffs2_iget(sb, ino);
93 }
94 
95 static struct dentry *jffs2_fh_to_dentry(struct super_block *sb, struct fid *fid,
96 					 int fh_len, int fh_type)
97 {
98         return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
99                                     jffs2_nfs_get_inode);
100 }
101 
102 static struct dentry *jffs2_fh_to_parent(struct super_block *sb, struct fid *fid,
103 					 int fh_len, int fh_type)
104 {
105         return generic_fh_to_parent(sb, fid, fh_len, fh_type,
106                                     jffs2_nfs_get_inode);
107 }
108 
109 static struct dentry *jffs2_get_parent(struct dentry *child)
110 {
111 	struct jffs2_inode_info *f;
112 	uint32_t pino;
113 
114 	BUG_ON(!S_ISDIR(child->d_inode->i_mode));
115 
116 	f = JFFS2_INODE_INFO(child->d_inode);
117 
118 	pino = f->inocache->pino_nlink;
119 
120 	JFFS2_DEBUG("Parent of directory ino #%u is #%u\n",
121 		    f->inocache->ino, pino);
122 
123 	return d_obtain_alias(jffs2_iget(child->d_inode->i_sb, pino));
124 }
125 
126 static const struct export_operations jffs2_export_ops = {
127 	.get_parent = jffs2_get_parent,
128 	.fh_to_dentry = jffs2_fh_to_dentry,
129 	.fh_to_parent = jffs2_fh_to_parent,
130 };
131 
132 static const struct super_operations jffs2_super_operations =
133 {
134 	.alloc_inode =	jffs2_alloc_inode,
135 	.destroy_inode =jffs2_destroy_inode,
136 	.put_super =	jffs2_put_super,
137 	.write_super =	jffs2_write_super,
138 	.statfs =	jffs2_statfs,
139 	.remount_fs =	jffs2_remount_fs,
140 	.clear_inode =	jffs2_clear_inode,
141 	.dirty_inode =	jffs2_dirty_inode,
142 	.sync_fs =	jffs2_sync_fs,
143 };
144 
145 /*
146  * fill in the superblock
147  */
148 static int jffs2_fill_super(struct super_block *sb, void *data, int silent)
149 {
150 	struct jffs2_sb_info *c;
151 
152 	D1(printk(KERN_DEBUG "jffs2_get_sb_mtd():"
153 		  " New superblock for device %d (\"%s\")\n",
154 		  sb->s_mtd->index, sb->s_mtd->name));
155 
156 	c = kzalloc(sizeof(*c), GFP_KERNEL);
157 	if (!c)
158 		return -ENOMEM;
159 
160 	c->mtd = sb->s_mtd;
161 	c->os_priv = sb;
162 	sb->s_fs_info = c;
163 
164 	/* Initialize JFFS2 superblock locks, the further initialization will
165 	 * be done later */
166 	mutex_init(&c->alloc_sem);
167 	mutex_init(&c->erase_free_sem);
168 	init_waitqueue_head(&c->erase_wait);
169 	init_waitqueue_head(&c->inocache_wq);
170 	spin_lock_init(&c->erase_completion_lock);
171 	spin_lock_init(&c->inocache_lock);
172 
173 	sb->s_op = &jffs2_super_operations;
174 	sb->s_export_op = &jffs2_export_ops;
175 	sb->s_flags = sb->s_flags | MS_NOATIME;
176 	sb->s_xattr = jffs2_xattr_handlers;
177 #ifdef CONFIG_JFFS2_FS_POSIX_ACL
178 	sb->s_flags |= MS_POSIXACL;
179 #endif
180 	return jffs2_do_fill_super(sb, data, silent);
181 }
182 
183 static int jffs2_get_sb(struct file_system_type *fs_type,
184 			int flags, const char *dev_name,
185 			void *data, struct vfsmount *mnt)
186 {
187 	return get_sb_mtd(fs_type, flags, dev_name, data, jffs2_fill_super,
188 			  mnt);
189 }
190 
191 static void jffs2_put_super (struct super_block *sb)
192 {
193 	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
194 
195 	D2(printk(KERN_DEBUG "jffs2: jffs2_put_super()\n"));
196 
197 	lock_kernel();
198 
199 	if (sb->s_dirt)
200 		jffs2_write_super(sb);
201 
202 	mutex_lock(&c->alloc_sem);
203 	jffs2_flush_wbuf_pad(c);
204 	mutex_unlock(&c->alloc_sem);
205 
206 	jffs2_sum_exit(c);
207 
208 	jffs2_free_ino_caches(c);
209 	jffs2_free_raw_node_refs(c);
210 	if (jffs2_blocks_use_vmalloc(c))
211 		vfree(c->blocks);
212 	else
213 		kfree(c->blocks);
214 	jffs2_flash_cleanup(c);
215 	kfree(c->inocache_list);
216 	jffs2_clear_xattr_subsystem(c);
217 	if (c->mtd->sync)
218 		c->mtd->sync(c->mtd);
219 
220 	unlock_kernel();
221 
222 	D1(printk(KERN_DEBUG "jffs2_put_super returning\n"));
223 }
224 
225 static void jffs2_kill_sb(struct super_block *sb)
226 {
227 	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
228 	if (!(sb->s_flags & MS_RDONLY))
229 		jffs2_stop_garbage_collect_thread(c);
230 	kill_mtd_super(sb);
231 	kfree(c);
232 }
233 
234 static struct file_system_type jffs2_fs_type = {
235 	.owner =	THIS_MODULE,
236 	.name =		"jffs2",
237 	.get_sb =	jffs2_get_sb,
238 	.kill_sb =	jffs2_kill_sb,
239 };
240 
241 static int __init init_jffs2_fs(void)
242 {
243 	int ret;
244 
245 	/* Paranoia checks for on-medium structures. If we ask GCC
246 	   to pack them with __attribute__((packed)) then it _also_
247 	   assumes that they're not aligned -- so it emits crappy
248 	   code on some architectures. Ideally we want an attribute
249 	   which means just 'no padding', without the alignment
250 	   thing. But GCC doesn't have that -- we have to just
251 	   hope the structs are the right sizes, instead. */
252 	BUILD_BUG_ON(sizeof(struct jffs2_unknown_node) != 12);
253 	BUILD_BUG_ON(sizeof(struct jffs2_raw_dirent) != 40);
254 	BUILD_BUG_ON(sizeof(struct jffs2_raw_inode) != 68);
255 	BUILD_BUG_ON(sizeof(struct jffs2_raw_summary) != 32);
256 
257 	printk(KERN_INFO "JFFS2 version 2.2."
258 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
259 	       " (NAND)"
260 #endif
261 #ifdef CONFIG_JFFS2_SUMMARY
262 	       " (SUMMARY) "
263 #endif
264 	       " © 2001-2006 Red Hat, Inc.\n");
265 
266 	jffs2_inode_cachep = kmem_cache_create("jffs2_i",
267 					     sizeof(struct jffs2_inode_info),
268 					     0, (SLAB_RECLAIM_ACCOUNT|
269 						SLAB_MEM_SPREAD),
270 					     jffs2_i_init_once);
271 	if (!jffs2_inode_cachep) {
272 		printk(KERN_ERR "JFFS2 error: Failed to initialise inode cache\n");
273 		return -ENOMEM;
274 	}
275 	ret = jffs2_compressors_init();
276 	if (ret) {
277 		printk(KERN_ERR "JFFS2 error: Failed to initialise compressors\n");
278 		goto out;
279 	}
280 	ret = jffs2_create_slab_caches();
281 	if (ret) {
282 		printk(KERN_ERR "JFFS2 error: Failed to initialise slab caches\n");
283 		goto out_compressors;
284 	}
285 	ret = register_filesystem(&jffs2_fs_type);
286 	if (ret) {
287 		printk(KERN_ERR "JFFS2 error: Failed to register filesystem\n");
288 		goto out_slab;
289 	}
290 	return 0;
291 
292  out_slab:
293 	jffs2_destroy_slab_caches();
294  out_compressors:
295 	jffs2_compressors_exit();
296  out:
297 	kmem_cache_destroy(jffs2_inode_cachep);
298 	return ret;
299 }
300 
301 static void __exit exit_jffs2_fs(void)
302 {
303 	unregister_filesystem(&jffs2_fs_type);
304 	jffs2_destroy_slab_caches();
305 	jffs2_compressors_exit();
306 	kmem_cache_destroy(jffs2_inode_cachep);
307 }
308 
309 module_init(init_jffs2_fs);
310 module_exit(exit_jffs2_fs);
311 
312 MODULE_DESCRIPTION("The Journalling Flash File System, v2");
313 MODULE_AUTHOR("Red Hat, Inc.");
314 MODULE_LICENSE("GPL"); // Actually dual-licensed, but it doesn't matter for
315 		       // the sake of this tag. It's Free Software.
316