ext4: Add fallback for find_group_flex
[safe/jmp/linux-2.6] / fs / hfsplus / super.c
index 0a92fa2..eb74531 100644 (file)
@@ -7,12 +7,10 @@
  *
  */
 
-#include <linux/config.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/pagemap.h>
 #include <linux/fs.h>
-#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/vfs.h>
 #include <linux/nls.h>
@@ -22,14 +20,21 @@ static void hfsplus_destroy_inode(struct inode *inode);
 
 #include "hfsplus_fs.h"
 
-static void hfsplus_read_inode(struct inode *inode)
+struct inode *hfsplus_iget(struct super_block *sb, unsigned long ino)
 {
        struct hfs_find_data fd;
        struct hfsplus_vh *vhdr;
-       int err;
+       struct inode *inode;
+       long err = -EIO;
+
+       inode = iget_locked(sb, ino);
+       if (!inode)
+               return ERR_PTR(-ENOMEM);
+       if (!(inode->i_state & I_NEW))
+               return inode;
 
        INIT_LIST_HEAD(&HFSPLUS_I(inode).open_dir_list);
-       init_MUTEX(&HFSPLUS_I(inode).extents_lock);
+       mutex_init(&HFSPLUS_I(inode).extents_lock);
        HFSPLUS_I(inode).flags = 0;
        HFSPLUS_I(inode).rsrc_inode = NULL;
        atomic_set(&HFSPLUS_I(inode).opencnt, 0);
@@ -43,7 +48,7 @@ static void hfsplus_read_inode(struct inode *inode)
                hfs_find_exit(&fd);
                if (err)
                        goto bad_inode;
-               return;
+               goto done;
        }
        vhdr = HFSPLUS_SB(inode->i_sb).s_vhdr;
        switch(inode->i_ino) {
@@ -72,10 +77,13 @@ static void hfsplus_read_inode(struct inode *inode)
                goto bad_inode;
        }
 
-       return;
+done:
+       unlock_new_inode(inode);
+       return inode;
 
- bad_inode:
-       make_bad_inode(inode);
+bad_inode:
+       iget_failed(inode);
+       return ERR_PTR(err);
 }
 
 static int hfsplus_write_inode(struct inode *inode, int unused)
@@ -261,10 +269,9 @@ static int hfsplus_remount(struct super_block *sb, int *flags, char *data)
        return 0;
 }
 
-static struct super_operations hfsplus_sops = {
+static const struct super_operations hfsplus_sops = {
        .alloc_inode    = hfsplus_alloc_inode,
        .destroy_inode  = hfsplus_destroy_inode,
-       .read_inode     = hfsplus_read_inode,
        .write_inode    = hfsplus_write_inode,
        .clear_inode    = hfsplus_clear_inode,
        .put_super      = hfsplus_put_super,
@@ -280,16 +287,15 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
        struct hfsplus_sb_info *sbi;
        hfsplus_cat_entry entry;
        struct hfs_find_data fd;
-       struct inode *root;
+       struct inode *root, *inode;
        struct qstr str;
        struct nls_table *nls = NULL;
        int err = -EINVAL;
 
-       sbi = kmalloc(sizeof(struct hfsplus_sb_info), GFP_KERNEL);
+       sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
        if (!sbi)
                return -ENOMEM;
 
-       memset(sbi, 0, sizeof(HFSPLUS_SB(sb)));
        sb->s_fs_info = sbi;
        INIT_HLIST_HEAD(&sbi->rsrc_inodes);
        hfsplus_fill_defaults(sbi);
@@ -350,8 +356,8 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
        } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_SOFTLOCK)) {
                printk(KERN_WARNING "hfs: Filesystem is marked locked, mounting read-only.\n");
                sb->s_flags |= MS_RDONLY;
-       } else if (vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) {
-               printk(KERN_WARNING "hfs: write access to a jounaled filesystem is not supported, "
+       } else if ((vhdr->attributes & cpu_to_be32(HFSPLUS_VOL_JOURNALED)) && !(sb->s_flags & MS_RDONLY)) {
+               printk(KERN_WARNING "hfs: write access to a journaled filesystem is not supported, "
                       "use the force option at your own risk, mounting read-only.\n");
                sb->s_flags |= MS_RDONLY;
        }
@@ -369,20 +375,28 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
                goto cleanup;
        }
 
-       HFSPLUS_SB(sb).alloc_file = iget(sb, HFSPLUS_ALLOC_CNID);
-       if (!HFSPLUS_SB(sb).alloc_file) {
+       inode = hfsplus_iget(sb, HFSPLUS_ALLOC_CNID);
+       if (IS_ERR(inode)) {
                printk(KERN_ERR "hfs: failed to load allocation file\n");
+               err = PTR_ERR(inode);
                goto cleanup;
        }
+       HFSPLUS_SB(sb).alloc_file = inode;
 
        /* Load the root directory */
-       root = iget(sb, HFSPLUS_ROOT_CNID);
+       root = hfsplus_iget(sb, HFSPLUS_ROOT_CNID);
+       if (IS_ERR(root)) {
+               printk(KERN_ERR "hfs: failed to load root directory\n");
+               err = PTR_ERR(root);
+               goto cleanup;
+       }
        sb->s_root = d_alloc_root(root);
        if (!sb->s_root) {
-               printk(KERN_ERR "hfs: failed to load root directory\n");
                iput(root);
+               err = -ENOMEM;
                goto cleanup;
        }
+       sb->s_root->d_op = &hfsplus_dentry_operations;
 
        str.len = sizeof(HFSP_HIDDENDIR_NAME) - 1;
        str.name = HFSP_HIDDENDIR_NAME;
@@ -392,9 +406,12 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
                hfs_find_exit(&fd);
                if (entry.type != cpu_to_be16(HFSPLUS_FOLDER))
                        goto cleanup;
-               HFSPLUS_SB(sb).hidden_dir = iget(sb, be32_to_cpu(entry.folder.id));
-               if (!HFSPLUS_SB(sb).hidden_dir)
+               inode = hfsplus_iget(sb, be32_to_cpu(entry.folder.id));
+               if (IS_ERR(inode)) {
+                       err = PTR_ERR(inode);
                        goto cleanup;
+               }
+               HFSPLUS_SB(sb).hidden_dir = inode;
        } else
                hfs_find_exit(&fd);
 
@@ -406,7 +423,7 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
         */
        vhdr->last_mount_vers = cpu_to_be32(HFSP_MOUNT_VERSION);
        vhdr->modify_date = hfsp_now2mt();
-       vhdr->write_count = cpu_to_be32(be32_to_cpu(vhdr->write_count) + 1);
+       be32_add_cpu(&vhdr->write_count, 1);
        vhdr->attributes &= cpu_to_be32(~HFSPLUS_VOL_UNMNT);
        vhdr->attributes |= cpu_to_be32(HFSPLUS_VOL_INCNSTNT);
        mark_buffer_dirty(HFSPLUS_SB(sb).s_vhbh);
@@ -435,13 +452,13 @@ MODULE_AUTHOR("Brad Boyer");
 MODULE_DESCRIPTION("Extended Macintosh Filesystem");
 MODULE_LICENSE("GPL");
 
-static kmem_cache_t *hfsplus_inode_cachep;
+static struct kmem_cache *hfsplus_inode_cachep;
 
 static struct inode *hfsplus_alloc_inode(struct super_block *sb)
 {
        struct hfsplus_inode_info *i;
 
-       i = kmem_cache_alloc(hfsplus_inode_cachep, SLAB_KERNEL);
+       i = kmem_cache_alloc(hfsplus_inode_cachep, GFP_KERNEL);
        return i ? &i->vfs_inode : NULL;
 }
 
@@ -468,12 +485,11 @@ static struct file_system_type hfsplus_fs_type = {
        .fs_flags       = FS_REQUIRES_DEV,
 };
 
-static void hfsplus_init_once(void *p, kmem_cache_t *cachep, unsigned long flags)
+static void hfsplus_init_once(void *p)
 {
        struct hfsplus_inode_info *i = p;
 
-       if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) == SLAB_CTOR_CONSTRUCTOR)
-               inode_init_once(&i->vfs_inode);
+       inode_init_once(&i->vfs_inode);
 }
 
 static int __init init_hfsplus_fs(void)
@@ -482,7 +498,7 @@ static int __init init_hfsplus_fs(void)
 
        hfsplus_inode_cachep = kmem_cache_create("hfsplus_icache",
                HFSPLUS_INODE_SIZE, 0, SLAB_HWCACHE_ALIGN,
-               hfsplus_init_once, NULL);
+               hfsplus_init_once);
        if (!hfsplus_inode_cachep)
                return -ENOMEM;
        err = register_filesystem(&hfsplus_fs_type);
@@ -494,8 +510,7 @@ static int __init init_hfsplus_fs(void)
 static void __exit exit_hfsplus_fs(void)
 {
        unregister_filesystem(&hfsplus_fs_type);
-       if (kmem_cache_destroy(hfsplus_inode_cachep))
-               printk(KERN_ERR "hfsplus_inode_cache: not all structures were freed\n");
+       kmem_cache_destroy(hfsplus_inode_cachep);
 }
 
 module_init(init_hfsplus_fs)