Root/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#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_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
74static 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
86static 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
95static 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
102static 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
109static 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
126static 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
132static 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 */
148static 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
183static 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
191static 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
225static 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
234static 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
241static 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
301static 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
309module_init(init_jffs2_fs);
310module_exit(exit_jffs2_fs);
311
312MODULE_DESCRIPTION("The Journalling Flash File System, v2");
313MODULE_AUTHOR("Red Hat, Inc.");
314MODULE_LICENSE("GPL"); // Actually dual-licensed, but it doesn't matter for
315               // the sake of this tag. It's Free Software.
316

Archive Download this file



interactive