BKL: Explicitly add BKL around get_sb/fill_super

This patch is a preparation necessary to remove the BKL from do_new_mount().
It explicitly adds calls to lock_kernel()/unlock_kernel() around
get_sb/fill_super operations for filesystems that still uses the BKL.

I've read through all the code formerly covered by the BKL inside
do_kern_mount() and have satisfied myself that it doesn't need the BKL
any more.

do_kern_mount() is already called without the BKL when mounting the rootfs
and in nfsctl. do_kern_mount() calls vfs_kern_mount(), which is called
from various places without BKL: simple_pin_fs(), nfs_do_clone_mount()
through nfs_follow_mountpoint(), afs_mntpt_do_automount() through
afs_mntpt_follow_link(). Both later functions are actually the filesystems
follow_link inode operation. vfs_kern_mount() is calling the specified
get_sb function and lets the filesystem do its job by calling the given
fill_super function.

Therefore I think it is safe to push down the BKL from the VFS to the
low-level filesystems get_sb/fill_super operation.

[arnd: do not add the BKL to those file systems that already
       don't use it elsewhere]

Signed-off-by: Jan Blunck <jblunck@infradead.org>
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Matthew Wilcox <matthew@wil.cx>
Cc: Christoph Hellwig <hch@infradead.org>

diff --git a/fs/adfs/super.c b/fs/adfs/super.c
index 4a3af7075c1d09058347ef532edc8c3105a9f9d5..d9803f73236f543fca9764cbe453414f6fe22286 100644 (file)
--- a/fs/adfs/super.c
+++ b/fs/adfs/super.c
@@ -352,11 +352,15 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
        struct adfs_sb_info *asb;
        struct inode *root;
 
+       lock_kernel();
+
        sb->s_flags |= MS_NODIRATIME;
 
        asb = kzalloc(sizeof(*asb), GFP_KERNEL);
-       if (!asb)
+       if (!asb) {
+               unlock_kernel();
                return -ENOMEM;
+       }
        sb->s_fs_info = asb;
 
        /* set default options */
@@ -474,6 +478,7 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
                goto error;
        } else
                sb->s_root->d_op = &adfs_dentry_operations;
+       unlock_kernel();
        return 0;
 
 error_free_bh:
@@ -481,6 +486,7 @@ error_free_bh:
 error:
        sb->s_fs_info = NULL;
        kfree(asb);
+       unlock_kernel();
        return -EINVAL;
 }
 

diff --git a/fs/affs/super.c b/fs/affs/super.c
index 33c4e7eef470e995246562b774fd88a82ca7f12b..3a6d1dee4a513dfc9bc798e7d5fd5feccb41d1b9 100644 (file)
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -291,6 +291,8 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
        u8                       sig[4];
        int                      ret = -EINVAL;
 
+       lock_kernel();
+
        save_mount_options(sb, data);
 
        pr_debug("AFFS: read_super(%s)\n",data ? (const char *)data : "no options");
@@ -300,8 +302,10 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_flags |= MS_NODIRATIME;
 
        sbi = kzalloc(sizeof(struct affs_sb_info), GFP_KERNEL);
-       if (!sbi)
+       if (!sbi) {
+               unlock_kernel();
                return -ENOMEM;
+       }
        sb->s_fs_info = sbi;
        mutex_init(&sbi->s_bmlock);
        spin_lock_init(&sbi->symlink_lock);
@@ -312,6 +316,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
                printk(KERN_ERR "AFFS: Error parsing options\n");
                kfree(sbi->s_prefix);
                kfree(sbi);
+               unlock_kernel();
                return -EINVAL;
        }
        /* N.B. after this point s_prefix must be released */
@@ -482,6 +487,7 @@ got_root:
        sb->s_root->d_op = &affs_dentry_operations;
 
        pr_debug("AFFS: s_flags=%lX\n",sb->s_flags);
+       unlock_kernel();
        return 0;
 
        /*
@@ -496,6 +502,7 @@ out_error_noinode:
        kfree(sbi->s_prefix);
        kfree(sbi);
        sb->s_fs_info = NULL;
+       unlock_kernel();
        return ret;
 }
 

diff --git a/fs/afs/super.c b/fs/afs/super.c
index 77e1e5a61154c6796d80d709ed31722017d90e18..6c2fef44d385da531e44561adc0ca39dce2d06fd 100644 (file)
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -302,12 +302,15 @@ static int afs_fill_super(struct super_block *sb, void *data)
        struct inode *inode = NULL;
        int ret;
 
+       lock_kernel();
+
        _enter("");
 
        /* allocate a superblock info record */
        as = kzalloc(sizeof(struct afs_super_info), GFP_KERNEL);
        if (!as) {
                _leave(" = -ENOMEM");
+               unlock_kernel();
                return -ENOMEM;
        }
 
@@ -341,6 +344,7 @@ static int afs_fill_super(struct super_block *sb, void *data)
        sb->s_root = root;
 
        _leave(" = 0");
+       unlock_kernel();
        return 0;
 
 error_inode:
@@ -354,6 +358,7 @@ error:
        sb->s_fs_info = NULL;
 
        _leave(" = %d", ret);
+       unlock_kernel();
        return ret;
 }
 

diff --git a/fs/bfs/inode.c b/fs/bfs/inode.c
index c4daf0f5fc021e9b98fa2521b96ee28ea67c9b4c..d2e09363dd93b83a331c872fdac705c6180a8701 100644 (file)
--- a/fs/bfs/inode.c
+++ b/fs/bfs/inode.c
@@ -322,9 +322,13 @@ static int bfs_fill_super(struct super_block *s, void *data, int silent)
        int ret = -EINVAL;
        unsigned long i_sblock, i_eblock, i_eoff, s_size;
 
+       lock_kernel();
+
        info = kzalloc(sizeof(*info), GFP_KERNEL);
-       if (!info)
+       if (!info) {
+               unlock_kernel();
                return -ENOMEM;
+       }
        mutex_init(&info->bfs_lock);
        s->s_fs_info = info;
 
@@ -439,6 +443,7 @@ static int bfs_fill_super(struct super_block *s, void *data, int silent)
        brelse(bh);
        brelse(sbh);
        dump_imap("read_super", s);
+       unlock_kernel();
        return 0;
 
 out3:
@@ -452,6 +457,7 @@ out:
        mutex_destroy(&info->bfs_lock);
        kfree(info);
        s->s_fs_info = NULL;
+       unlock_kernel();
        return ret;
 }
 

diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index b7431afdd76d57fb17ef70385428dd5c132020f2..070bf1aecd2dd3148e164025798f4256799e2a1a 100644 (file)
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -514,22 +514,30 @@ cifs_get_sb(struct file_system_type *fs_type,
            int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
        int rc;
-       struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
+       struct super_block *sb;
+
+       lock_kernel();
+
+       sb = sget(fs_type, NULL, set_anon_super, NULL);
 
        cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
 
-       if (IS_ERR(sb))
+       if (IS_ERR(sb)) {
+               unlock_kernel();
                return PTR_ERR(sb);
+       }
 
        sb->s_flags = flags;
 
        rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
        if (rc) {
                deactivate_locked_super(sb);
+               unlock_kernel();
                return rc;
        }
        sb->s_flags |= MS_ACTIVE;
        simple_set_mnt(mnt, sb);
+       unlock_kernel();
        return 0;
 }
 

diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index 6526e6f21ecfb22f23a5b19efb5b9d82287cef49..bfe8179b1295e76ea4433fce9d2533e240eed840 100644 (file)
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -148,6 +148,8 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent)
        int error;
        int idx;
 
+       lock_kernel();
+
        idx = get_device_index((struct coda_mount_data *) data);
 
        /* Ignore errors in data, for backward compatibility */
@@ -159,11 +161,13 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent)
        vc = &coda_comms[idx];
        if (!vc->vc_inuse) {
                printk("coda_read_super: No pseudo device\n");
+               unlock_kernel();
                return -EINVAL;
        }
 
         if ( vc->vc_sb ) {
                printk("coda_read_super: Device already mounted\n");
+               unlock_kernel();
                return -EBUSY;
        }
 
@@ -202,7 +206,8 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_root = d_alloc_root(root);
        if (!sb->s_root)
                goto error;
-        return 0;
+       unlock_kernel();
+       return 0;
 
  error:
        bdi_destroy(&vc->bdi);
@@ -212,6 +217,7 @@ static int coda_fill_super(struct super_block *sb, void *data, int silent)
        if (vc)
                vc->vc_sb = NULL;
 
+       unlock_kernel();
        return -EINVAL;
 }
 

diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index cbd4e18adb204438d45b865469d38b7af97a9904..c4af92fa12c3ef4b4d2266048eff2c6884c49f92 100644 (file)
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -36,6 +36,7 @@
 #include <linux/parser.h>
 #include <linux/fs_stack.h>
 #include <linux/slab.h>
+#include <linux/smp_lock.h>     /* For lock_kernel() */
 #include "ecryptfs_kernel.h"
 
 /**
@@ -550,6 +551,7 @@ static int ecryptfs_get_sb(struct file_system_type *fs_type, int flags,
        const char *err = "Getting sb failed";
        int rc;
 
+       lock_kernel();
        sbi = kmem_cache_zalloc(ecryptfs_sb_info_cache, GFP_KERNEL);
        if (!sbi) {
                rc = -ENOMEM;
@@ -608,6 +610,7 @@ static int ecryptfs_get_sb(struct file_system_type *fs_type, int flags,
                goto out;
        }
        simple_set_mnt(mnt, s);
+       unlock_kernel();
        return 0;
 
 out:
@@ -616,6 +619,7 @@ out:
                kmem_cache_free(ecryptfs_sb_info_cache, sbi);
        }
        printk(KERN_ERR "%s; rc = [%d]\n", err, rc);
+       unlock_kernel();
        return rc;
 }
 

diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 1ec602673ea8d37c3ddd72c7016ca1783ca8cf74..f98c390caf1d0dcffba2e22e2cfc7d7b6ba9620c 100644 (file)
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -747,15 +747,18 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
        __le32 features;
        int err;
 
+       lock_kernel();
+
+       err = -ENOMEM;
        sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
        if (!sbi)
-               return -ENOMEM;
+               goto failed_unlock;
 
        sbi->s_blockgroup_lock =
                kzalloc(sizeof(struct blockgroup_lock), GFP_KERNEL);
        if (!sbi->s_blockgroup_lock) {
                kfree(sbi);
-               return -ENOMEM;
+               goto failed_unlock;
        }
        sb->s_fs_info = sbi;
        sbi->s_sb_block = sb_block;
@@ -1083,6 +1086,7 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
        if (ext2_setup_super (sb, es, sb->s_flags & MS_RDONLY))
                sb->s_flags |= MS_RDONLY;
        ext2_write_super(sb);
+       unlock_kernel();
        return 0;
 
 cantfind_ext2:
@@ -1107,6 +1111,8 @@ failed_sbi:
        sb->s_fs_info = NULL;
        kfree(sbi->s_blockgroup_lock);
        kfree(sbi);
+failed_unlock:
+       unlock_kernel();
        return ret;
 }
 

diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 5dbf4dba03c4d99240edd76de5e9a0a2bba4bd04..41f9dcd73e9734d9caac2506e5486db2ca648b0e 100644 (file)
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -1611,14 +1611,19 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
        __le32 features;
        int err;
 
+       lock_kernel();
+
        sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
-       if (!sbi)
+       if (!sbi) {
+               unlock_kernel();
                return -ENOMEM;
+       }
 
        sbi->s_blockgroup_lock =
                kzalloc(sizeof(struct blockgroup_lock), GFP_KERNEL);
        if (!sbi->s_blockgroup_lock) {
                kfree(sbi);
+               unlock_kernel();
                return -ENOMEM;
        }
        sb->s_fs_info = sbi;
@@ -2026,6 +2031,7 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
                "writeback");
 
        lock_kernel();
+       unlock_kernel();
        return 0;
 
 cantfind_ext3:
@@ -2056,6 +2062,7 @@ out_fail:
        kfree(sbi->s_blockgroup_lock);
        kfree(sbi);
        lock_kernel();
+       unlock_kernel();
        return ret;
 }
 

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 26147746c272c2112b7067aa6415800434586b50..0f0021f4990c38d58e373be71d5c3085c2bd3d9c 100644 (file)
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -2568,6 +2568,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
        int err;
        unsigned int journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
 
+       lock_kernel();
+
        sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
        if (!sbi)
                goto out_free_orig;
@@ -3166,7 +3168,6 @@ no_journal:
        if (es->s_error_count)
                mod_timer(&sbi->s_err_report, jiffies + 300*HZ); /* 5 minutes */
 
-       lock_kernel();
        kfree(orig_data);
        return 0;
 
@@ -3213,8 +3214,11 @@ out_fail:
        sb->s_fs_info = NULL;
        kfree(sbi->s_blockgroup_lock);
        kfree(sbi);
-       lock_kernel();
+       kfree(orig_data);
+       return ret;
+
 out_free_orig:
+       unlock_kernel();
        kfree(orig_data);
        return ret;
 }

diff --git a/fs/fat/namei_msdos.c b/fs/fat/namei_msdos.c
index bbc94ae4fd77150203435058b79e46a03bfb40bc..e2b0b978340d7ea63e1c4be0ddd1f411fc653ef4 100644 (file)
--- a/fs/fat/namei_msdos.c
+++ b/fs/fat/namei_msdos.c
@@ -9,6 +9,7 @@
 #include <linux/module.h>
 #include <linux/time.h>
 #include <linux/buffer_head.h>
+#include <linux/smp_lock.h>     /* For lock_kernel() */
 #include "fat.h"
 
 /* Characters that are undesirable in an MS-DOS file name */
@@ -662,12 +663,16 @@ static int msdos_fill_super(struct super_block *sb, void *data, int silent)
 {
        int res;
 
+       lock_kernel();
        res = fat_fill_super(sb, data, silent, &msdos_dir_inode_operations, 0);
-       if (res)
+       if (res) {
+               unlock_kernel();
                return res;
+       }
 
        sb->s_flags |= MS_NOATIME;
        sb->s_root->d_op = &msdos_dentry_operations;
+       unlock_kernel();
        return 0;
 }
 

diff --git a/fs/fat/namei_vfat.c b/fs/fat/namei_vfat.c
index 6fcc7e71fbaaf0c8f1d21b3cf50fab86d67f50ee..9006ad9c7b11f43ed2ea7cf08d57b52f47d897c5 100644 (file)
--- a/fs/fat/namei_vfat.c
+++ b/fs/fat/namei_vfat.c
@@ -21,6 +21,7 @@
 #include <linux/slab.h>
 #include <linux/buffer_head.h>
 #include <linux/namei.h>
+#include <linux/smp_lock.h>     /* For lock_kernel() */
 #include "fat.h"
 
 /*
@@ -1055,15 +1056,19 @@ static int vfat_fill_super(struct super_block *sb, void *data, int silent)
 {
        int res;
 
+       lock_kernel();
        res = fat_fill_super(sb, data, silent, &vfat_dir_inode_operations, 1);
-       if (res)
+       if (res) {
+               unlock_kernel();
                return res;
+       }
 
        if (MSDOS_SB(sb)->options.name_check != 's')
                sb->s_root->d_op = &vfat_ci_dentry_ops;
        else
                sb->s_root->d_op = &vfat_dentry_ops;
 
+       unlock_kernel();
        return 0;
 }
 

diff --git a/fs/freevxfs/vxfs_super.c b/fs/freevxfs/vxfs_super.c
index dc0c041e85cbcd5c14b04c0e5b09eda611605aef..eb2b9e09c99624917c8d5cb843437ba06d773d2a 100644 (file)
--- a/fs/freevxfs/vxfs_super.c
+++ b/fs/freevxfs/vxfs_super.c
@@ -148,7 +148,7 @@ static int vxfs_remount(struct super_block *sb, int *flags, char *data)
  *   The superblock on success, else %NULL.
  *
  * Locking:
- *   We are under the bkl and @sbp->s_lock.
+ *   We are under @sbp->s_lock.
  */
 static int vxfs_fill_super(struct super_block *sbp, void *dp, int silent)
 {
@@ -159,11 +159,14 @@ static int vxfs_fill_super(struct super_block *sbp, void *dp, int silent)
        struct inode *root;
        int ret = -EINVAL;
 
+       lock_kernel();
+
        sbp->s_flags |= MS_RDONLY;
 
        infp = kzalloc(sizeof(*infp), GFP_KERNEL);
        if (!infp) {
                printk(KERN_WARNING "vxfs: unable to allocate incore superblock\n");
+               unlock_kernel();
                return -ENOMEM;
        }
 
@@ -236,6 +239,7 @@ static int vxfs_fill_super(struct super_block *sbp, void *dp, int silent)
                goto out_free_ilist;
        }
 
+       unlock_kernel();
        return 0;
        
 out_free_ilist:
@@ -245,6 +249,7 @@ out_free_ilist:
 out:
        brelse(bp);
        kfree(infp);
+       unlock_kernel();
        return ret;
 }
 

diff --git a/fs/hfs/super.c b/fs/hfs/super.c
index 34235d4bf08bb5921768b1105b37bfff4277cd7a..3069416fa8ef1ce8bb8ae0d1867ed94879740bdc 100644 (file)
--- a/fs/hfs/super.c
+++ b/fs/hfs/super.c
@@ -382,9 +382,13 @@ static int hfs_fill_super(struct super_block *sb, void *data, int silent)
        struct inode *root_inode;
        int res;
 
+       lock_kernel();
+
        sbi = kzalloc(sizeof(struct hfs_sb_info), GFP_KERNEL);
-       if (!sbi)
+       if (!sbi) {
+               unlock_kernel();
                return -ENOMEM;
+       }
        sb->s_fs_info = sbi;
        INIT_HLIST_HEAD(&sbi->rsrc_inodes);
 
@@ -435,6 +439,7 @@ static int hfs_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_root->d_op = &hfs_dentry_operations;
 
        /* everything's okay */
+       unlock_kernel();
        return 0;
 
 bail_iput:
@@ -443,6 +448,7 @@ bail_no_root:
        printk(KERN_ERR "hfs: get root inode failed.\n");
 bail:
        hfs_mdb_put(sb);
+       unlock_kernel();
        return res;
 }
 

diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
index 2607010be2fe5019b9700926d57c0f272be79f17..c969a1aa163a7cd3fb0b48094edf1ac90f63816c 100644 (file)
--- a/fs/hpfs/super.c
+++ b/fs/hpfs/super.c
@@ -477,11 +477,15 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
 
        int o;
 
+       lock_kernel();
+
        save_mount_options(s, options);
 
        sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
-       if (!sbi)
+       if (!sbi) {
+               unlock_kernel();
                return -ENOMEM;
+       }
        s->s_fs_info = sbi;
 
        sbi->sb_bmp_dir = NULL;
@@ -666,6 +670,7 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
                        root->i_blocks = 5;
                hpfs_brelse4(&qbh);
        }
+       unlock_kernel();
        return 0;
 
 bail4: brelse(bh2);
@@ -677,6 +682,7 @@ bail0:
        kfree(sbi->sb_cp_table);
        s->s_fs_info = NULL;
        kfree(sbi);
+       unlock_kernel();
        return -EINVAL;
 }
 

diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index 5a44811b5027ab73958ec6d87757a44dee5ff911..05baf7721e8cefcec26092644833507b058f0e6e 100644 (file)
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -571,11 +571,15 @@ static int isofs_fill_super(struct super_block *s, void *data, int silent)
        int table, error = -EINVAL;
        unsigned int vol_desc_start;
 
+       lock_kernel();
+
        save_mount_options(s, data);
 
        sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
-       if (!sbi)
+       if (!sbi) {
+               unlock_kernel();
                return -ENOMEM;
+       }
        s->s_fs_info = sbi;
 
        if (!parse_options((char *)data, &opt))
@@ -900,6 +904,7 @@ root_found:
 
        kfree(opt.iocharset);
 
+       unlock_kernel();
        return 0;
 
        /*
@@ -939,6 +944,7 @@ out_freesbi:
        kfree(opt.iocharset);
        kfree(sbi);
        s->s_fs_info = NULL;
+       unlock_kernel();
        return error;
 }
 

diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index 662bba099501277caff6bd0b0c54abe1aaddf8cf..58dd9cf062069a0011d15da72ffffba0b3eed456 100644 (file)
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -146,14 +146,19 @@ static const struct super_operations jffs2_super_operations =
 static int jffs2_fill_super(struct super_block *sb, void *data, int silent)
 {
        struct jffs2_sb_info *c;
+       int ret;
+
+       lock_kernel();
 
        D1(printk(KERN_DEBUG "jffs2_get_sb_mtd():"
                  " New superblock for device %d (\"%s\")\n",
                  sb->s_mtd->index, sb->s_mtd->name));
 
        c = kzalloc(sizeof(*c), GFP_KERNEL);
-       if (!c)
+       if (!c) {
+               unlock_kernel();
                return -ENOMEM;
+       }
 
        c->mtd = sb->s_mtd;
        c->os_priv = sb;
@@ -175,7 +180,9 @@ static int jffs2_fill_super(struct super_block *sb, void *data, int silent)
 #ifdef CONFIG_JFFS2_FS_POSIX_ACL
        sb->s_flags |= MS_POSIXACL;
 #endif
-       return jffs2_do_fill_super(sb, data, silent);
+       ret = jffs2_do_fill_super(sb, data, silent);
+       unlock_kernel();
+       return ret;
 }
 
 static int jffs2_get_sb(struct file_system_type *fs_type,

diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index ec8c3e4baca3f78d666c33982d7040afcf73628b..eb31f677347d5b7cacc6bb79eb1dbd1ce0433ea4 100644 (file)
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -438,14 +438,20 @@ static int jfs_fill_super(struct super_block *sb, void *data, int silent)
        s64 newLVSize = 0;
        int flag, ret = -EINVAL;
 
+       lock_kernel();
+
        jfs_info("In jfs_read_super: s_flags=0x%lx", sb->s_flags);
 
-       if (!new_valid_dev(sb->s_bdev->bd_dev))
+       if (!new_valid_dev(sb->s_bdev->bd_dev)) {
+               unlock_kernel();
                return -EOVERFLOW;
+       }
 
        sbi = kzalloc(sizeof (struct jfs_sb_info), GFP_KERNEL);
-       if (!sbi)
+       if (!sbi) {
+               unlock_kernel();
                return -ENOMEM;
+       }
        sb->s_fs_info = sbi;
        sbi->sb = sb;
        sbi->uid = sbi->gid = sbi->umask = -1;
@@ -542,6 +548,7 @@ static int jfs_fill_super(struct super_block *sb, void *data, int silent)
        sb->s_maxbytes = min(((u64) PAGE_CACHE_SIZE << 32) - 1, (u64)sb->s_maxbytes);
 #endif
        sb->s_time_gran = 1;
+       unlock_kernel();
        return 0;
 
 out_no_root:
@@ -564,6 +571,7 @@ out_unload:
                unload_nls(sbi->nls_tab);
 out_kfree:
        kfree(sbi);
+       unlock_kernel();
        return ret;
 }
 

diff --git a/fs/nilfs2/super.c b/fs/nilfs2/super.c
index 922263393c765664f6b5598f4c144093ec9e582c..0d573c2a68605c805d6077b55602943ca288197b 100644 (file)
--- a/fs/nilfs2/super.c
+++ b/fs/nilfs2/super.c
@@ -1113,9 +1113,12 @@ nilfs_get_sb(struct file_system_type *fs_type, int flags,
        if (!(flags & MS_RDONLY))
                mode |= FMODE_WRITE;
 
+       lock_kernel();
        sd.bdev = open_bdev_exclusive(dev_name, mode, fs_type);
-       if (IS_ERR(sd.bdev))
+       if (IS_ERR(sd.bdev)) {
+               unlock_kernel();
                return PTR_ERR(sd.bdev);
+       }
 
        /*
         * To get mount instance using sget() vfs-routine, NILFS needs
@@ -1198,6 +1201,7 @@ nilfs_get_sb(struct file_system_type *fs_type, int flags,
        if (need_to_close)
                close_bdev_exclusive(sd.bdev, mode);
        simple_set_mnt(mnt, s);
+       unlock_kernel();
        return 0;
 
  failed_unlock:
@@ -1206,6 +1210,7 @@ nilfs_get_sb(struct file_system_type *fs_type, int flags,
  failed:
        close_bdev_exclusive(sd.bdev, mode);
 
+       unlock_kernel();
        return err;
 
  cancel_new:
@@ -1218,6 +1223,7 @@ nilfs_get_sb(struct file_system_type *fs_type, int flags,
         * We must finish all post-cleaning before this call;
         * put_nilfs() needs the block device.
         */
+       unlock_kernel();
        return err;
 }
 

diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
index 512806171bfa2e2dfb73975feb60ea9560a654a7..1f31e77fc41fbdb1af183060314de6cd89ca0d82 100644 (file)
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -2732,6 +2732,8 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
        struct inode *tmp_ino;
        int blocksize, result;
 
+       lock_kernel();
+
        /*
         * We do a pretty difficult piece of bootstrap by reading the
         * MFT (and other metadata) from disk into memory. We'll only
@@ -2755,6 +2757,7 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
                        ntfs_error(sb, "Allocation of NTFS volume structure "
                                        "failed. Aborting mount...");
                lockdep_on();
+               unlock_kernel();
                return -ENOMEM;
        }
        /* Initialize ntfs_volume structure. */
@@ -2942,6 +2945,7 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
                sb->s_export_op = &ntfs_export_ops;
                lock_kernel();
                lockdep_on();
+               unlock_kernel();
                return 0;
        }
        ntfs_error(sb, "Failed to allocate root directory.");
@@ -3062,6 +3066,7 @@ err_out_now:
        kfree(vol);
        ntfs_debug("Failed, returning -EINVAL.");
        lockdep_on();
+       unlock_kernel();
        return -EINVAL;
 }
 

diff --git a/fs/ocfs2/dlmfs/dlmfs.c b/fs/ocfs2/dlmfs/dlmfs.c
index c2903b84bb7a8ccbc0ea099e4a8585559d3fcf67..667d7ceba8c92ee7177847e9ecab9b6be000a6b8 100644 (file)
--- a/fs/ocfs2/dlmfs/dlmfs.c
+++ b/fs/ocfs2/dlmfs/dlmfs.c
@@ -44,6 +44,7 @@
 #include <linux/string.h>
 #include <linux/backing-dev.h>
 #include <linux/poll.h>
+#include <linux/smp_lock.h>
 
 #include <asm/uaccess.h>
 
@@ -588,21 +589,27 @@ static int dlmfs_fill_super(struct super_block * sb,
        struct inode * inode;
        struct dentry * root;
 
+       lock_kernel();
+
        sb->s_maxbytes = MAX_LFS_FILESIZE;
        sb->s_blocksize = PAGE_CACHE_SIZE;
        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
        sb->s_magic = DLMFS_MAGIC;
        sb->s_op = &dlmfs_ops;
        inode = dlmfs_get_root_inode(sb);
-       if (!inode)
+       if (!inode) {
+               unlock_kernel();
                return -ENOMEM;
+       }
 
        root = d_alloc_root(inode);
        if (!root) {
                iput(inode);
+               unlock_kernel();
                return -ENOMEM;
        }
        sb->s_root = root;
+       unlock_kernel();
        return 0;
 }
 

diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index fa1be1b304d10b7bf30c4ecb2c7a3fd9b3ecd8ca..b7e4f2d19d401238c40d66912e1a8607107417ab 100644 (file)
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -1002,6 +1002,8 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
        char nodestr[8];
        struct ocfs2_blockcheck_stats stats;
 
+       lock_kernel();
+
        mlog_entry("%p, %p, %i", sb, data, silent);
 
        if (!ocfs2_parse_options(sb, data, &parsed_options, 0)) {
@@ -1179,6 +1181,7 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
                        atomic_set(&osb->vol_state, VOLUME_DISABLED);
                        wake_up(&osb->osb_mount_event);
                        mlog_exit(status);
+                       unlock_kernel();
                        return status;
                }
        }
@@ -1193,6 +1196,7 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
        ocfs2_orphan_scan_start(osb);
 
        mlog_exit(status);
+       unlock_kernel();
        return status;
 
 read_super_error:
@@ -1208,6 +1212,7 @@ read_super_error:
        }
 
        mlog_exit(status);
+       unlock_kernel();
        return status;
 }
 

diff --git a/fs/qnx4/inode.c b/fs/qnx4/inode.c
index 16829722be93658abb8a153bff2422396c02e8b0..86a7be1399a891879672bdbf93d57f82e6872652 100644 (file)
--- a/fs/qnx4/inode.c
+++ b/fs/qnx4/inode.c
@@ -234,9 +234,13 @@ static int qnx4_fill_super(struct super_block *s, void *data, int silent)
        struct qnx4_sb_info *qs;
        int ret = -EINVAL;
 
+       lock_kernel();
+
        qs = kzalloc(sizeof(struct qnx4_sb_info), GFP_KERNEL);
-       if (!qs)
+       if (!qs) {
+               unlock_kernel();
                return -ENOMEM;
+       }
        s->s_fs_info = qs;
 
        sb_set_blocksize(s, QNX4_BLOCK_SIZE);
@@ -284,6 +288,7 @@ static int qnx4_fill_super(struct super_block *s, void *data, int silent)
 
        brelse(bh);
 
+       unlock_kernel();
        return 0;
 
       outi:
@@ -293,6 +298,7 @@ static int qnx4_fill_super(struct super_block *s, void *data, int silent)
       outnobh:
        kfree(qs);
        s->s_fs_info = NULL;
+       unlock_kernel();
        return ret;
 }
 

diff --git a/fs/smbfs/inode.c b/fs/smbfs/inode.c
index 450c9194198861483daa183fb6582e1c9790eadb..8fc5e50e142fad71ad05aa38f726ae0d6d4ca566 100644 (file)
--- a/fs/smbfs/inode.c
+++ b/fs/smbfs/inode.c
@@ -501,6 +501,8 @@ static int smb_fill_super(struct super_block *sb, void *raw_data, int silent)
        void *mem;
        static int warn_count;
 
+       lock_kernel();
+
        if (warn_count < 5) {
                warn_count++;
                printk(KERN_EMERG "smbfs is deprecated and will be removed"
@@ -621,6 +623,7 @@ static int smb_fill_super(struct super_block *sb, void *raw_data, int silent)
 
        smb_new_dentry(sb->s_root);
 
+       unlock_kernel();
        return 0;
 
 out_no_root:
@@ -643,9 +646,11 @@ out_wrong_data:
 out_no_data:
        printk(KERN_ERR "smb_fill_super: missing data argument\n");
 out_fail:
+       unlock_kernel();
        return -EINVAL;
 out_no_server:
        printk(KERN_ERR "smb_fill_super: cannot allocate struct smb_sb_info\n");
+       unlock_kernel();
        return -ENOMEM;
 }
 

diff --git a/fs/squashfs/super.c b/fs/squashfs/super.c
index 88b4f8606652b8e675621a2f545aff357ea176ae..ab1a401a0e19085531234eb0bb8b05838abdbfe6 100644 (file)
--- a/fs/squashfs/super.c
+++ b/fs/squashfs/super.c
@@ -87,11 +87,14 @@ static int squashfs_fill_super(struct super_block *sb, void *data, int silent)
        u64 lookup_table_start, xattr_id_table_start;
        int err;
 
+       lock_kernel();
+
        TRACE("Entered squashfs_fill_superblock\n");
 
        sb->s_fs_info = kzalloc(sizeof(*msblk), GFP_KERNEL);
        if (sb->s_fs_info == NULL) {
                ERROR("Failed to allocate squashfs_sb_info\n");
+               unlock_kernel();
                return -ENOMEM;
        }
        msblk = sb->s_fs_info;
@@ -301,6 +304,7 @@ allocate_root:
 
        TRACE("Leaving squashfs_fill_super\n");
        kfree(sblk);
+       unlock_kernel();
        return 0;
 
 failed_mount:
@@ -315,11 +319,13 @@ failed_mount:
        kfree(sb->s_fs_info);
        sb->s_fs_info = NULL;
        kfree(sblk);
+       unlock_kernel();
        return err;
 
 failure:
        kfree(sb->s_fs_info);
        sb->s_fs_info = NULL;
+       unlock_kernel();
        return -ENOMEM;
 }
 

diff --git a/fs/udf/super.c b/fs/udf/super.c
index 65412d84a45d7c5e6e8563111c7ca4b66cec32b7..76f3d6d97b402ea14c391c46b8a924af9888cc6c 100644 (file)
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -1880,6 +1880,8 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
        struct kernel_lb_addr rootdir, fileset;
        struct udf_sb_info *sbi;
 
+       lock_kernel();
+
        uopt.flags = (1 << UDF_FLAG_USE_AD_IN_ICB) | (1 << UDF_FLAG_STRICT);
        uopt.uid = -1;
        uopt.gid = -1;
@@ -1888,8 +1890,10 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
        uopt.dmode = UDF_INVALID_MODE;
 
        sbi = kzalloc(sizeof(struct udf_sb_info), GFP_KERNEL);
-       if (!sbi)
+       if (!sbi) {
+               unlock_kernel();
                return -ENOMEM;
+       }
 
        sb->s_fs_info = sbi;
 
@@ -2035,6 +2039,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
                goto error_out;
        }
        sb->s_maxbytes = MAX_LFS_FILESIZE;
+       unlock_kernel();
        return 0;
 
 error_out:
@@ -2055,6 +2060,7 @@ error_out:
        kfree(sbi);
        sb->s_fs_info = NULL;
 
+       unlock_kernel();
        return -EINVAL;
 }
 

diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index d510c1b91817c9543ea5da4f062af0cc7eb3ae4f..6b9be90dae7dd7affc1ccba35c02bd9fac193570 100644 (file)
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -696,6 +696,8 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
        unsigned maxsymlen;
        int ret = -EINVAL;
 
+       lock_kernel();
+
        uspi = NULL;
        ubh = NULL;
        flags = 0;
@@ -1163,6 +1165,7 @@ magic_found:
                        goto failed;
 
        UFSD("EXIT\n");
+       unlock_kernel();
        return 0;
 
 dalloc_failed:
@@ -1174,10 +1177,12 @@ failed:
        kfree(sbi);
        sb->s_fs_info = NULL;
        UFSD("EXIT (FAILED)\n");
+       unlock_kernel();
        return ret;
 
 failed_nomem:
        UFSD("EXIT (NOMEM)\n");
+       unlock_kernel();
        return -ENOMEM;
 }
 

diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index c9483d8f6140ed6cb4e06fa6139e2aeb907b3d47..a7ba3bccadc56c01cd2bc2964506592a4e70a14d 100644 (file)
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -1430,6 +1430,8 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
        struct super_block *sb;
        struct cgroupfs_root *new_root;
 
+       lock_kernel();
+
        /* First find the desired set of subsystems */
        mutex_lock(&cgroup_mutex);
        ret = parse_cgroupfs_options(data, &opts);
@@ -1559,6 +1561,7 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
        simple_set_mnt(mnt, sb);
        kfree(opts.release_agent);
        kfree(opts.name);
+       unlock_kernel();
        return 0;
 
  drop_new_super:
@@ -1568,6 +1571,7 @@ static int cgroup_get_sb(struct file_system_type *fs_type,
  out_err:
        kfree(opts.release_agent);
        kfree(opts.name);
+       unlock_kernel();
 
        return ret;
 }