Replace BKL with superblock lock in fat/msdos/vfat

This replaces the use of the BKL in the FAT family of filesystems with the
existing superblock lock instead.

The code already appears to do mostly proper locking with its own private
spinlocks (and mutexes), but while the BKL could possibly have been
dropped entirely, converting it to use the superblock lock (which is just
a regular mutex) is the conservative thing to do.

As a per-filesystem mutex, it not only won't have any of the possible
latency issues related to the BKL, but the lock is obviously private to
the particular filesystem instance and will thus not cause problems for
entirely unrelated users like the BKL can.

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Cc: OGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
Signed-off-by: Jonathan Corbet <corbet@lwn.net>

4 files changed, 26 insertions, 18 deletions

diff --git a/fs/fat/cache.c b/fs/fat/cache.c
index fda25479af26..3a9ecac8d61f 100644
--- a/fs/fat/cache.c
+++ b/fs/fat/cache.c
@@ -61,7 +61,7 @@ void fat_cache_destroy(void)
 
 static inline struct fat_cache *fat_cache_alloc(struct inode *inode)
 {
-        return kmem_cache_alloc(fat_cache_cachep, GFP_KERNEL);
+        return kmem_cache_alloc(fat_cache_cachep, GFP_NOFS);
 }
 
 static inline void fat_cache_free(struct fat_cache *cache)
diff --git a/fs/fat/dir.c b/fs/fat/dir.c
index 486725ee99ae..34541d06e626 100644
--- a/fs/fat/dir.c
+++ b/fs/fat/dir.c
@@ -472,7 +472,7 @@ static int __fat_readdir(struct inode *inode, struct file *filp, void *dirent,
         loff_t cpos;
         int ret = 0;
 
-        lock_kernel();
+        lock_super(sb);
 
         cpos = filp->f_pos;
         /* Fake . and .. for the root directory. */
@@ -654,7 +654,7 @@ FillFailed:
         if (unicode)
                 __putname(unicode);
 out:
-        unlock_kernel();
+        unlock_super(sb);
         return ret;
 }
 
diff --git a/fs/fat/file.c b/fs/fat/file.c
index 27cc1164ec36..7059928fb351 100644
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -229,7 +229,8 @@ static int fat_free(struct inode *inode, int skip)
 
 void fat_truncate(struct inode *inode)
 {
-        struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
+        struct super_block *sb = inode->i_sb;
+        struct msdos_sb_info *sbi = MSDOS_SB(sb);
         const unsigned int cluster_size = sbi->cluster_size;
         int nr_clusters;
 
@@ -242,9 +243,9 @@ void fat_truncate(struct inode *inode)
 
         nr_clusters = (inode->i_size + (cluster_size - 1)) >> sbi->cluster_bits;
 
-        lock_kernel();
+        lock_super(sb);
         fat_free(inode, nr_clusters);
-        unlock_kernel();
+        unlock_super(sb);
         fat_flush_inodes(inode->i_sb, inode, NULL);
 }
 
@@ -297,12 +298,13 @@ static int fat_allow_set_time(struct msdos_sb_info *sbi, struct inode *inode)
 
 int fat_setattr(struct dentry *dentry, struct iattr *attr)
 {
+        struct super_block *sb = dentry->d_sb;
         struct msdos_sb_info *sbi = MSDOS_SB(dentry->d_sb);
         struct inode *inode = dentry->d_inode;
         int mask, error = 0;
         unsigned int ia_valid;
 
-        lock_kernel();
+        lock_super(sb);
 
         /*
          * Expand the file. Since inode_setattr() updates ->i_size
@@ -356,7 +358,7 @@ int fat_setattr(struct dentry *dentry, struct iattr *attr)
                 mask = sbi->options.fs_fmask;
         inode->i_mode &= S_IFMT | (S_IRWXUGO & ~mask);
 out:
-        unlock_kernel();
+        unlock_super(sb);
         return error;
 }
 EXPORT_SYMBOL_GPL(fat_setattr);
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 4e0a3dd9d677..46a4508ffd2e 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -440,14 +440,13 @@ static void fat_delete_inode(struct inode *inode)
 
 static void fat_clear_inode(struct inode *inode)
 {
-        struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
+        struct super_block *sb = inode->i_sb;
+        struct msdos_sb_info *sbi = MSDOS_SB(sb);
 
-        lock_kernel();
         spin_lock(&sbi->inode_hash_lock);
         fat_cache_inval_inode(inode);
         hlist_del_init(&MSDOS_I(inode)->i_fat_hash);
         spin_unlock(&sbi->inode_hash_lock);
-        unlock_kernel();
 }
 
 static void fat_write_super(struct super_block *sb)
@@ -485,7 +484,7 @@ static struct kmem_cache *fat_inode_cachep;
 static struct inode *fat_alloc_inode(struct super_block *sb)
 {
         struct msdos_inode_info *ei;
-        ei = kmem_cache_alloc(fat_inode_cachep, GFP_KERNEL);
+        ei = kmem_cache_alloc(fat_inode_cachep, GFP_NOFS);
         if (!ei)
                 return NULL;
         return &ei->vfs_inode;
@@ -567,7 +566,7 @@ retry:
         if (inode->i_ino == MSDOS_ROOT_INO || !i_pos)
                 return 0;
 
-        lock_kernel();
+        lock_super(sb);
         bh = sb_bread(sb, i_pos >> sbi->dir_per_block_bits);
         if (!bh) {
                 printk(KERN_ERR "FAT: unable to read inode block "
@@ -579,7 +578,7 @@ retry:
         if (i_pos != MSDOS_I(inode)->i_pos) {
                 spin_unlock(&sbi->inode_hash_lock);
                 brelse(bh);
-                unlock_kernel();
+                unlock_super(sb);
                 goto retry;
         }
 
@@ -606,7 +605,7 @@ retry:
                 err = sync_dirty_buffer(bh);
         brelse(bh);
 out:
-        unlock_kernel();
+        unlock_super(sb);
         return err;
 }
 
@@ -736,6 +735,7 @@ fat_encode_fh(struct dentry *de, __u32 *fh, int *lenp, int connectable)
 
 static struct dentry *fat_get_parent(struct dentry *child)
 {
+        struct super_block *sb = child->d_sb;
         struct buffer_head *bh;
         struct msdos_dir_entry *de;
         loff_t i_pos;
@@ -743,14 +743,14 @@ static struct dentry *fat_get_parent(struct dentry *child)
         struct inode *inode;
         int err;
 
-        lock_kernel();
+        lock_super(sb);
 
         err = fat_get_dotdot_entry(child->d_inode, &bh, &de, &i_pos);
         if (err) {
                 parent = ERR_PTR(err);
                 goto out;
         }
-        inode = fat_build_inode(child->d_sb, de, i_pos);
+        inode = fat_build_inode(sb, de, i_pos);
         brelse(bh);
         if (IS_ERR(inode)) {
                 parent = ERR_CAST(inode);
@@ -762,7 +762,7 @@ static struct dentry *fat_get_parent(struct dentry *child)
                 parent = ERR_PTR(-ENOMEM);
         }
 out:
-        unlock_kernel();
+        unlock_super(sb);
 
         return parent;
 }
@@ -1172,6 +1172,12 @@ int fat_fill_super(struct super_block *sb, void *data, int silent,
         long error;
         char buf[50];
 
+        /*
+         * GFP_KERNEL is ok here, because while we do hold the
+         * supeblock lock, memory pressure can't call back into
+         * the filesystem, since we're only just about to mount
+         * it and have no inodes etc active!
+         */
         sbi = kzalloc(sizeof(struct msdos_sb_info), GFP_KERNEL);
         if (!sbi)
                 return -ENOMEM;