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