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