get rid of BKL in fs/minix

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

3 files changed, 14 insertions, 20 deletions

diff --git a/fs/minix/bitmap.c b/fs/minix/bitmap.c
index 3aebe322271a..6ac693faae49 100644
--- a/fs/minix/bitmap.c
+++ b/fs/minix/bitmap.c
@@ -12,13 +12,14 @@
 /* bitmap.c contains the code that handles the inode and block bitmaps */
 
 #include "minix.h"
-#include <linux/smp_lock.h>
 #include <linux/buffer_head.h>
 #include <linux/bitops.h>
 #include <linux/sched.h>
 
 static const int nibblemap[] = { 4,3,3,2,3,2,2,1,3,2,2,1,2,1,1,0 };
 
+static DEFINE_SPINLOCK(bitmap_lock);
+
 static unsigned long count_free(struct buffer_head *map[], unsigned numblocks, __u32 numbits)
 {
         unsigned i, j, sum = 0;
@@ -69,11 +70,11 @@ void minix_free_block(struct inode *inode, unsigned long block)
                 return;
         }
         bh = sbi->s_zmap[zone];
-        lock_kernel();
+        spin_lock(&bitmap_lock);
         if (!minix_test_and_clear_bit(bit, bh->b_data))
                 printk("minix_free_block (%s:%lu): bit already cleared\n",
                        sb->s_id, block);
-        unlock_kernel();
+        spin_unlock(&bitmap_lock);
         mark_buffer_dirty(bh);
         return;
 }
@@ -88,18 +89,18 @@ int minix_new_block(struct inode * inode)
                 struct buffer_head *bh = sbi->s_zmap[i];
                 int j;
 
-                lock_kernel();
+                spin_lock(&bitmap_lock);
                 j = minix_find_first_zero_bit(bh->b_data, bits_per_zone);
                 if (j < bits_per_zone) {
                         minix_set_bit(j, bh->b_data);
-                        unlock_kernel();
+                        spin_unlock(&bitmap_lock);
                         mark_buffer_dirty(bh);
                         j += i * bits_per_zone + sbi->s_firstdatazone-1;
                         if (j < sbi->s_firstdatazone || j >= sbi->s_nzones)
                                 break;
                         return j;
                 }
-                unlock_kernel();
+                spin_unlock(&bitmap_lock);
         }
         return 0;
 }
@@ -211,10 +212,10 @@ void minix_free_inode(struct inode * inode)
         minix_clear_inode(inode);       /* clear on-disk copy */
 
         bh = sbi->s_imap[ino];
-        lock_kernel();
+        spin_lock(&bitmap_lock);
         if (!minix_test_and_clear_bit(bit, bh->b_data))
                 printk("minix_free_inode: bit %lu already cleared\n", bit);
-        unlock_kernel();
+        spin_unlock(&bitmap_lock);
         mark_buffer_dirty(bh);
  out:
         clear_inode(inode);             /* clear in-memory copy */
@@ -237,7 +238,7 @@ struct inode * minix_new_inode(const struct inode * dir, int * error)
         j = bits_per_zone;
         bh = NULL;
         *error = -ENOSPC;
-        lock_kernel();
+        spin_lock(&bitmap_lock);
         for (i = 0; i < sbi->s_imap_blocks; i++) {
                 bh = sbi->s_imap[i];
                 j = minix_find_first_zero_bit(bh->b_data, bits_per_zone);
@@ -245,17 +246,17 @@ struct inode * minix_new_inode(const struct inode * dir, int * error)
                         break;
         }
         if (!bh || j >= bits_per_zone) {
-                unlock_kernel();
+                spin_unlock(&bitmap_lock);
                 iput(inode);
                 return NULL;
         }
         if (minix_test_and_set_bit(j, bh->b_data)) {    /* shouldn't happen */
-                unlock_kernel();
+                spin_unlock(&bitmap_lock);
                 printk("minix_new_inode: bit already set\n");
                 iput(inode);
                 return NULL;
         }
-        unlock_kernel();
+        spin_unlock(&bitmap_lock);
         mark_buffer_dirty(bh);
         j += i * bits_per_zone;
         if (!j || j > sbi->s_ninodes) {
diff --git a/fs/minix/dir.c b/fs/minix/dir.c
index e5f206467e40..d407e7a0b6fe 100644
--- a/fs/minix/dir.c
+++ b/fs/minix/dir.c
@@ -11,7 +11,6 @@
 #include "minix.h"
 #include <linux/buffer_head.h>
 #include <linux/highmem.h>
-#include <linux/smp_lock.h>
 #include <linux/swap.h>
 
 typedef struct minix_dir_entry minix_dirent;
@@ -20,6 +19,7 @@ typedef struct minix3_dir_entry minix3_dirent;
 static int minix_readdir(struct file *, void *, filldir_t);
 
 const struct file_operations minix_dir_operations = {
+        .llseek         = generic_file_llseek,
         .read           = generic_read_dir,
         .readdir        = minix_readdir,
         .fsync          = simple_fsync,
@@ -102,8 +102,6 @@ static int minix_readdir(struct file * filp, void * dirent, filldir_t filldir)
         char *name;
         __u32 inumber;
 
-        lock_kernel();
-
         pos = (pos + chunk_size-1) & ~(chunk_size-1);
         if (pos >= inode->i_size)
                 goto done;
@@ -146,7 +144,6 @@ static int minix_readdir(struct file * filp, void * dirent, filldir_t filldir)
 
 done:
         filp->f_pos = (n << PAGE_CACHE_SHIFT) | offset;
-        unlock_kernel();
         return 0;
 }
 
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index f91a23693597..74ea82d72164 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -35,8 +35,6 @@ static void minix_put_super(struct super_block *sb)
         int i;
         struct minix_sb_info *sbi = minix_sb(sb);
 
-        lock_kernel();
-
         if (!(sb->s_flags & MS_RDONLY)) {
                 if (sbi->s_version != MINIX_V3)  /* s_state is now out from V3 sb */
                         sbi->s_ms->s_state = sbi->s_mount_state;
@@ -50,8 +48,6 @@ static void minix_put_super(struct super_block *sb)
         kfree(sbi->s_imap);
         sb->s_fs_info = NULL;
         kfree(sbi);
-
-        unlock_kernel();
 }
 
 static struct kmem_cache * minix_inode_cachep;