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/init.h> 16 #include <linux/list.h> 17 #include <linux/fs.h> 18 #include <linux/err.h> 19 #include <linux/mount.h> 20 #include <linux/jffs2.h> 21 #include <linux/pagemap.h> 22 #include <linux/mtd/super.h> 23 #include <linux/ctype.h> 24 #include <linux/namei.h> 25 #include "compr.h" 26 #include "nodelist.h" 27 28 static void jffs2_put_super(struct super_block *); 29 30 static struct kmem_cache *jffs2_inode_cachep; 31 32 static struct inode *jffs2_alloc_inode(struct super_block *sb) 33 { 34 struct jffs2_inode_info *ei; 35 ei = (struct jffs2_inode_info *)kmem_cache_alloc(jffs2_inode_cachep, GFP_KERNEL); 36 if (!ei) 37 return NULL; 38 return &ei->vfs_inode; 39 } 40 41 static void jffs2_destroy_inode(struct inode *inode) 42 { 43 kmem_cache_free(jffs2_inode_cachep, JFFS2_INODE_INFO(inode)); 44 } 45 46 static void jffs2_i_init_once(struct kmem_cache *cachep, void *foo) 47 { 48 struct jffs2_inode_info *ei = (struct jffs2_inode_info *) foo; 49 50 init_MUTEX(&ei->sem); 51 inode_init_once(&ei->vfs_inode); 52 } 53 54 static int jffs2_sync_fs(struct super_block *sb, int wait) 55 { 56 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); 57 58 down(&c->alloc_sem); 59 jffs2_flush_wbuf_pad(c); 60 up(&c->alloc_sem); 61 return 0; 62 } 63 64 static const struct super_operations jffs2_super_operations = 65 { 66 .alloc_inode = jffs2_alloc_inode, 67 .destroy_inode =jffs2_destroy_inode, 68 .put_super = jffs2_put_super, 69 .write_super = jffs2_write_super, 70 .statfs = jffs2_statfs, 71 .remount_fs = jffs2_remount_fs, 72 .clear_inode = jffs2_clear_inode, 73 .dirty_inode = jffs2_dirty_inode, 74 .sync_fs = jffs2_sync_fs, 75 }; 76 77 /* 78 * fill in the superblock 79 */ 80 static int jffs2_fill_super(struct super_block *sb, void *data, int silent) 81 { 82 struct jffs2_sb_info *c; 83 84 D1(printk(KERN_DEBUG "jffs2_get_sb_mtd():" 85 " New superblock for device %d (\"%s\")\n", 86 sb->s_mtd->index, sb->s_mtd->name)); 87 88 c = kzalloc(sizeof(*c), GFP_KERNEL); 89 if (!c) 90 return -ENOMEM; 91 92 c->mtd = sb->s_mtd; 93 c->os_priv = sb; 94 sb->s_fs_info = c; 95 96 /* Initialize JFFS2 superblock locks, the further initialization will 97 * be done later */ 98 init_MUTEX(&c->alloc_sem); 99 init_MUTEX(&c->erase_free_sem); 100 init_waitqueue_head(&c->erase_wait); 101 init_waitqueue_head(&c->inocache_wq); 102 spin_lock_init(&c->erase_completion_lock); 103 spin_lock_init(&c->inocache_lock); 104 105 sb->s_op = &jffs2_super_operations; 106 sb->s_flags = sb->s_flags | MS_NOATIME; 107 sb->s_xattr = jffs2_xattr_handlers; 108 #ifdef CONFIG_JFFS2_FS_POSIX_ACL 109 sb->s_flags |= MS_POSIXACL; 110 #endif 111 return jffs2_do_fill_super(sb, data, silent); 112 } 113 114 static int jffs2_get_sb(struct file_system_type *fs_type, 115 int flags, const char *dev_name, 116 void *data, struct vfsmount *mnt) 117 { 118 return get_sb_mtd(fs_type, flags, dev_name, data, jffs2_fill_super, 119 mnt); 120 } 121 122 static void jffs2_put_super (struct super_block *sb) 123 { 124 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); 125 126 D2(printk(KERN_DEBUG "jffs2: jffs2_put_super()\n")); 127 128 down(&c->alloc_sem); 129 jffs2_flush_wbuf_pad(c); 130 up(&c->alloc_sem); 131 132 jffs2_sum_exit(c); 133 134 jffs2_free_ino_caches(c); 135 jffs2_free_raw_node_refs(c); 136 if (jffs2_blocks_use_vmalloc(c)) 137 vfree(c->blocks); 138 else 139 kfree(c->blocks); 140 jffs2_flash_cleanup(c); 141 kfree(c->inocache_list); 142 jffs2_clear_xattr_subsystem(c); 143 if (c->mtd->sync) 144 c->mtd->sync(c->mtd); 145 146 D1(printk(KERN_DEBUG "jffs2_put_super returning\n")); 147 } 148 149 static void jffs2_kill_sb(struct super_block *sb) 150 { 151 struct jffs2_sb_info *c = JFFS2_SB_INFO(sb); 152 if (!(sb->s_flags & MS_RDONLY)) 153 jffs2_stop_garbage_collect_thread(c); 154 kill_mtd_super(sb); 155 kfree(c); 156 } 157 158 static struct file_system_type jffs2_fs_type = { 159 .owner = THIS_MODULE, 160 .name = "jffs2", 161 .get_sb = jffs2_get_sb, 162 .kill_sb = jffs2_kill_sb, 163 }; 164 165 static int __init init_jffs2_fs(void) 166 { 167 int ret; 168 169 /* Paranoia checks for on-medium structures. If we ask GCC 170 to pack them with __attribute__((packed)) then it _also_ 171 assumes that they're not aligned -- so it emits crappy 172 code on some architectures. Ideally we want an attribute 173 which means just 'no padding', without the alignment 174 thing. But GCC doesn't have that -- we have to just 175 hope the structs are the right sizes, instead. */ 176 BUILD_BUG_ON(sizeof(struct jffs2_unknown_node) != 12); 177 BUILD_BUG_ON(sizeof(struct jffs2_raw_dirent) != 40); 178 BUILD_BUG_ON(sizeof(struct jffs2_raw_inode) != 68); 179 BUILD_BUG_ON(sizeof(struct jffs2_raw_summary) != 32); 180 181 printk(KERN_INFO "JFFS2 version 2.2." 182 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER 183 " (NAND)" 184 #endif 185 #ifdef CONFIG_JFFS2_SUMMARY 186 " (SUMMARY) " 187 #endif 188 " © 2001-2006 Red Hat, Inc.\n"); 189 190 jffs2_inode_cachep = kmem_cache_create("jffs2_i", 191 sizeof(struct jffs2_inode_info), 192 0, (SLAB_RECLAIM_ACCOUNT| 193 SLAB_MEM_SPREAD), 194 jffs2_i_init_once); 195 if (!jffs2_inode_cachep) { 196 printk(KERN_ERR "JFFS2 error: Failed to initialise inode cache\n"); 197 return -ENOMEM; 198 } 199 ret = jffs2_compressors_init(); 200 if (ret) { 201 printk(KERN_ERR "JFFS2 error: Failed to initialise compressors\n"); 202 goto out; 203 } 204 ret = jffs2_create_slab_caches(); 205 if (ret) { 206 printk(KERN_ERR "JFFS2 error: Failed to initialise slab caches\n"); 207 goto out_compressors; 208 } 209 ret = register_filesystem(&jffs2_fs_type); 210 if (ret) { 211 printk(KERN_ERR "JFFS2 error: Failed to register filesystem\n"); 212 goto out_slab; 213 } 214 return 0; 215 216 out_slab: 217 jffs2_destroy_slab_caches(); 218 out_compressors: 219 jffs2_compressors_exit(); 220 out: 221 kmem_cache_destroy(jffs2_inode_cachep); 222 return ret; 223 } 224 225 static void __exit exit_jffs2_fs(void) 226 { 227 unregister_filesystem(&jffs2_fs_type); 228 jffs2_destroy_slab_caches(); 229 jffs2_compressors_exit(); 230 kmem_cache_destroy(jffs2_inode_cachep); 231 } 232 233 module_init(init_jffs2_fs); 234 module_exit(exit_jffs2_fs); 235 236 MODULE_DESCRIPTION("The Journalling Flash File System, v2"); 237 MODULE_AUTHOR("Red Hat, Inc."); 238 MODULE_LICENSE("GPL"); // Actually dual-licensed, but it doesn't matter for 239 // the sake of this tag. It's Free Software. 240