f9916f312bd81e3590fde1c92a025458cb64ab11
[linux-3.10.git] / fs / jffs2 / super.c
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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/init.h>
18 #include <linux/list.h>
19 #include <linux/fs.h>
20 #include <linux/err.h>
21 #include <linux/mount.h>
22 #include <linux/parser.h>
23 #include <linux/jffs2.h>
24 #include <linux/pagemap.h>
25 #include <linux/mtd/super.h>
26 #include <linux/ctype.h>
27 #include <linux/namei.h>
28 #include <linux/seq_file.h>
29 #include <linux/exportfs.h>
30 #include "compr.h"
31 #include "nodelist.h"
32
33 static void jffs2_put_super(struct super_block *);
34
35 static struct kmem_cache *jffs2_inode_cachep;
36
37 static struct inode *jffs2_alloc_inode(struct super_block *sb)
38 {
39         struct jffs2_inode_info *f;
40
41         f = kmem_cache_alloc(jffs2_inode_cachep, GFP_KERNEL);
42         if (!f)
43                 return NULL;
44         return &f->vfs_inode;
45 }
46
47 static void jffs2_i_callback(struct rcu_head *head)
48 {
49         struct inode *inode = container_of(head, struct inode, i_rcu);
50         kmem_cache_free(jffs2_inode_cachep, JFFS2_INODE_INFO(inode));
51 }
52
53 static void jffs2_destroy_inode(struct inode *inode)
54 {
55         call_rcu(&inode->i_rcu, jffs2_i_callback);
56 }
57
58 static void jffs2_i_init_once(void *foo)
59 {
60         struct jffs2_inode_info *f = foo;
61
62         mutex_init(&f->sem);
63         inode_init_once(&f->vfs_inode);
64 }
65
66 static void jffs2_write_super(struct super_block *sb)
67 {
68         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
69
70         lock_super(sb);
71         sb->s_dirt = 0;
72
73         if (!(sb->s_flags & MS_RDONLY)) {
74                 jffs2_dbg(1, "%s()\n", __func__);
75                 jffs2_flush_wbuf_gc(c, 0);
76         }
77
78         unlock_super(sb);
79 }
80
81 static const char *jffs2_compr_name(unsigned int compr)
82 {
83         switch (compr) {
84         case JFFS2_COMPR_MODE_NONE:
85                 return "none";
86 #ifdef CONFIG_JFFS2_LZO
87         case JFFS2_COMPR_MODE_FORCELZO:
88                 return "lzo";
89 #endif
90 #ifdef CONFIG_JFFS2_ZLIB
91         case JFFS2_COMPR_MODE_FORCEZLIB:
92                 return "zlib";
93 #endif
94         default:
95                 /* should never happen; programmer error */
96                 WARN_ON(1);
97                 return "";
98         }
99 }
100
101 static int jffs2_show_options(struct seq_file *s, struct dentry *root)
102 {
103         struct jffs2_sb_info *c = JFFS2_SB_INFO(root->d_sb);
104         struct jffs2_mount_opts *opts = &c->mount_opts;
105
106         if (opts->override_compr)
107                 seq_printf(s, ",compr=%s", jffs2_compr_name(opts->compr));
108
109         return 0;
110 }
111
112 static int jffs2_sync_fs(struct super_block *sb, int wait)
113 {
114         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
115
116         jffs2_write_super(sb);
117
118         mutex_lock(&c->alloc_sem);
119         jffs2_flush_wbuf_pad(c);
120         mutex_unlock(&c->alloc_sem);
121         return 0;
122 }
123
124 static struct inode *jffs2_nfs_get_inode(struct super_block *sb, uint64_t ino,
125                                          uint32_t generation)
126 {
127         /* We don't care about i_generation. We'll destroy the flash
128            before we start re-using inode numbers anyway. And even
129            if that wasn't true, we'd have other problems...*/
130         return jffs2_iget(sb, ino);
131 }
132
133 static struct dentry *jffs2_fh_to_dentry(struct super_block *sb, struct fid *fid,
134                                          int fh_len, int fh_type)
135 {
136         return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
137                                     jffs2_nfs_get_inode);
138 }
139
140 static struct dentry *jffs2_fh_to_parent(struct super_block *sb, struct fid *fid,
141                                          int fh_len, int fh_type)
142 {
143         return generic_fh_to_parent(sb, fid, fh_len, fh_type,
144                                     jffs2_nfs_get_inode);
145 }
146
147 static struct dentry *jffs2_get_parent(struct dentry *child)
148 {
149         struct jffs2_inode_info *f;
150         uint32_t pino;
151
152         BUG_ON(!S_ISDIR(child->d_inode->i_mode));
153
154         f = JFFS2_INODE_INFO(child->d_inode);
155
156         pino = f->inocache->pino_nlink;
157
158         JFFS2_DEBUG("Parent of directory ino #%u is #%u\n",
159                     f->inocache->ino, pino);
160
161         return d_obtain_alias(jffs2_iget(child->d_inode->i_sb, pino));
162 }
163
164 static const struct export_operations jffs2_export_ops = {
165         .get_parent = jffs2_get_parent,
166         .fh_to_dentry = jffs2_fh_to_dentry,
167         .fh_to_parent = jffs2_fh_to_parent,
168 };
169
170 /*
171  * JFFS2 mount options.
172  *
173  * Opt_override_compr: override default compressor
174  * Opt_err: just end of array marker
175  */
176 enum {
177         Opt_override_compr,
178         Opt_err,
179 };
180
181 static const match_table_t tokens = {
182         {Opt_override_compr, "compr=%s"},
183         {Opt_err, NULL},
184 };
185
186 static int jffs2_parse_options(struct jffs2_sb_info *c, char *data)
187 {
188         substring_t args[MAX_OPT_ARGS];
189         char *p, *name;
190
191         if (!data)
192                 return 0;
193
194         while ((p = strsep(&data, ","))) {
195                 int token;
196
197                 if (!*p)
198                         continue;
199
200                 token = match_token(p, tokens, args);
201                 switch (token) {
202                 case Opt_override_compr:
203                         name = match_strdup(&args[0]);
204
205                         if (!name)
206                                 return -ENOMEM;
207                         if (!strcmp(name, "none"))
208                                 c->mount_opts.compr = JFFS2_COMPR_MODE_NONE;
209 #ifdef CONFIG_JFFS2_LZO
210                         else if (!strcmp(name, "lzo"))
211                                 c->mount_opts.compr = JFFS2_COMPR_MODE_FORCELZO;
212 #endif
213 #ifdef CONFIG_JFFS2_ZLIB
214                         else if (!strcmp(name, "zlib"))
215                                 c->mount_opts.compr =
216                                                 JFFS2_COMPR_MODE_FORCEZLIB;
217 #endif
218                         else {
219                                 pr_err("Error: unknown compressor \"%s\"\n",
220                                        name);
221                                 kfree(name);
222                                 return -EINVAL;
223                         }
224                         kfree(name);
225                         c->mount_opts.override_compr = true;
226                         break;
227                 default:
228                         pr_err("Error: unrecognized mount option '%s' or missing value\n",
229                                p);
230                         return -EINVAL;
231                 }
232         }
233
234         return 0;
235 }
236
237 static int jffs2_remount_fs(struct super_block *sb, int *flags, char *data)
238 {
239         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
240         int err;
241
242         err = jffs2_parse_options(c, data);
243         if (err)
244                 return -EINVAL;
245
246         return jffs2_do_remount_fs(sb, flags, data);
247 }
248
249 static const struct super_operations jffs2_super_operations =
250 {
251         .alloc_inode =  jffs2_alloc_inode,
252         .destroy_inode =jffs2_destroy_inode,
253         .put_super =    jffs2_put_super,
254         .write_super =  jffs2_write_super,
255         .statfs =       jffs2_statfs,
256         .remount_fs =   jffs2_remount_fs,
257         .evict_inode =  jffs2_evict_inode,
258         .dirty_inode =  jffs2_dirty_inode,
259         .show_options = jffs2_show_options,
260         .sync_fs =      jffs2_sync_fs,
261 };
262
263 /*
264  * fill in the superblock
265  */
266 static int jffs2_fill_super(struct super_block *sb, void *data, int silent)
267 {
268         struct jffs2_sb_info *c;
269         int ret;
270
271         jffs2_dbg(1, "jffs2_get_sb_mtd():"
272                   " New superblock for device %d (\"%s\")\n",
273                   sb->s_mtd->index, sb->s_mtd->name);
274
275         c = kzalloc(sizeof(*c), GFP_KERNEL);
276         if (!c)
277                 return -ENOMEM;
278
279         c->mtd = sb->s_mtd;
280         c->os_priv = sb;
281         sb->s_fs_info = c;
282
283         ret = jffs2_parse_options(c, data);
284         if (ret) {
285                 kfree(c);
286                 return -EINVAL;
287         }
288
289         /* Initialize JFFS2 superblock locks, the further initialization will
290          * be done later */
291         mutex_init(&c->alloc_sem);
292         mutex_init(&c->erase_free_sem);
293         init_waitqueue_head(&c->erase_wait);
294         init_waitqueue_head(&c->inocache_wq);
295         spin_lock_init(&c->erase_completion_lock);
296         spin_lock_init(&c->inocache_lock);
297
298         sb->s_op = &jffs2_super_operations;
299         sb->s_export_op = &jffs2_export_ops;
300         sb->s_flags = sb->s_flags | MS_NOATIME;
301         sb->s_xattr = jffs2_xattr_handlers;
302 #ifdef CONFIG_JFFS2_FS_POSIX_ACL
303         sb->s_flags |= MS_POSIXACL;
304 #endif
305         ret = jffs2_do_fill_super(sb, data, silent);
306         return ret;
307 }
308
309 static struct dentry *jffs2_mount(struct file_system_type *fs_type,
310                         int flags, const char *dev_name,
311                         void *data)
312 {
313         return mount_mtd(fs_type, flags, dev_name, data, jffs2_fill_super);
314 }
315
316 static void jffs2_put_super (struct super_block *sb)
317 {
318         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
319
320         jffs2_dbg(2, "%s()\n", __func__);
321
322         if (sb->s_dirt)
323                 jffs2_write_super(sb);
324
325         mutex_lock(&c->alloc_sem);
326         jffs2_flush_wbuf_pad(c);
327         mutex_unlock(&c->alloc_sem);
328
329         jffs2_sum_exit(c);
330
331         jffs2_free_ino_caches(c);
332         jffs2_free_raw_node_refs(c);
333         if (jffs2_blocks_use_vmalloc(c))
334                 vfree(c->blocks);
335         else
336                 kfree(c->blocks);
337         jffs2_flash_cleanup(c);
338         kfree(c->inocache_list);
339         jffs2_clear_xattr_subsystem(c);
340         mtd_sync(c->mtd);
341         jffs2_dbg(1, "%s(): returning\n", __func__);
342 }
343
344 static void jffs2_kill_sb(struct super_block *sb)
345 {
346         struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
347         if (!(sb->s_flags & MS_RDONLY))
348                 jffs2_stop_garbage_collect_thread(c);
349         kill_mtd_super(sb);
350         kfree(c);
351 }
352
353 static struct file_system_type jffs2_fs_type = {
354         .owner =        THIS_MODULE,
355         .name =         "jffs2",
356         .mount =        jffs2_mount,
357         .kill_sb =      jffs2_kill_sb,
358 };
359
360 static int __init init_jffs2_fs(void)
361 {
362         int ret;
363
364         /* Paranoia checks for on-medium structures. If we ask GCC
365            to pack them with __attribute__((packed)) then it _also_
366            assumes that they're not aligned -- so it emits crappy
367            code on some architectures. Ideally we want an attribute
368            which means just 'no padding', without the alignment
369            thing. But GCC doesn't have that -- we have to just
370            hope the structs are the right sizes, instead. */
371         BUILD_BUG_ON(sizeof(struct jffs2_unknown_node) != 12);
372         BUILD_BUG_ON(sizeof(struct jffs2_raw_dirent) != 40);
373         BUILD_BUG_ON(sizeof(struct jffs2_raw_inode) != 68);
374         BUILD_BUG_ON(sizeof(struct jffs2_raw_summary) != 32);
375
376         pr_info("version 2.2."
377 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
378                " (NAND)"
379 #endif
380 #ifdef CONFIG_JFFS2_SUMMARY
381                " (SUMMARY) "
382 #endif
383                " © 2001-2006 Red Hat, Inc.\n");
384
385         jffs2_inode_cachep = kmem_cache_create("jffs2_i",
386                                              sizeof(struct jffs2_inode_info),
387                                              0, (SLAB_RECLAIM_ACCOUNT|
388                                                 SLAB_MEM_SPREAD),
389                                              jffs2_i_init_once);
390         if (!jffs2_inode_cachep) {
391                 pr_err("error: Failed to initialise inode cache\n");
392                 return -ENOMEM;
393         }
394         ret = jffs2_compressors_init();
395         if (ret) {
396                 pr_err("error: Failed to initialise compressors\n");
397                 goto out;
398         }
399         ret = jffs2_create_slab_caches();
400         if (ret) {
401                 pr_err("error: Failed to initialise slab caches\n");
402                 goto out_compressors;
403         }
404         ret = register_filesystem(&jffs2_fs_type);
405         if (ret) {
406                 pr_err("error: Failed to register filesystem\n");
407                 goto out_slab;
408         }
409         return 0;
410
411  out_slab:
412         jffs2_destroy_slab_caches();
413  out_compressors:
414         jffs2_compressors_exit();
415  out:
416         kmem_cache_destroy(jffs2_inode_cachep);
417         return ret;
418 }
419
420 static void __exit exit_jffs2_fs(void)
421 {
422         unregister_filesystem(&jffs2_fs_type);
423         jffs2_destroy_slab_caches();
424         jffs2_compressors_exit();
425         kmem_cache_destroy(jffs2_inode_cachep);
426 }
427
428 module_init(init_jffs2_fs);
429 module_exit(exit_jffs2_fs);
430
431 MODULE_DESCRIPTION("The Journalling Flash File System, v2");
432 MODULE_AUTHOR("Red Hat, Inc.");
433 MODULE_LICENSE("GPL"); // Actually dual-licensed, but it doesn't matter for
434                        // the sake of this tag. It's Free Software.