adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-28 03:36:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

get rid of BKL in fs/minix

Browse source 
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
This commit is contained in:
Al Viro 2009-06-16 23:47:45 -04:00
parent e7ec952f6a
commit cc46759a8c
3 changed files with 14 additions and 20 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
fs/minix/bitmap.c
View file

@ -12,13 +12,14 @@
/* bitmap.c contains the code that handles the inode and block bitmaps */ /* bitmap.c contains the code that handles the inode and block bitmaps */
#include "minix.h" #include "minix.h"
#include <linux/smp_lock.h>
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#include <linux/bitops.h> #include <linux/bitops.h>
#include <linux/sched.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 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) static unsigned long count_free(struct buffer_head *map[], unsigned numblocks, __u32 numbits)
{ {
unsigned i, j, sum = 0; unsigned i, j, sum = 0;
@ -69,11 +70,11 @@ void minix_free_block(struct inode *inode, unsigned long block)
return; return;
} }
bh = sbi->s_zmap[zone]; bh = sbi->s_zmap[zone];
lock_kernel(); spin_lock(&bitmap_lock);
if (!minix_test_and_clear_bit(bit, bh->b_data)) if (!minix_test_and_clear_bit(bit, bh->b_data))
printk("minix_free_block (%s:%lu): bit already cleared\n", printk("minix_free_block (%s:%lu): bit already cleared\n",
sb->s_id, block); sb->s_id, block);
unlock_kernel(); spin_unlock(&bitmap_lock);
mark_buffer_dirty(bh); mark_buffer_dirty(bh);
return; return;
} }
@ -88,18 +89,18 @@ int minix_new_block(struct inode * inode)
struct buffer_head *bh = sbi->s_zmap[i]; struct buffer_head *bh = sbi->s_zmap[i];
int j; int j;
lock_kernel(); spin_lock(&bitmap_lock);
j = minix_find_first_zero_bit(bh->b_data, bits_per_zone); j = minix_find_first_zero_bit(bh->b_data, bits_per_zone);
if (j < bits_per_zone) { if (j < bits_per_zone) {
minix_set_bit(j, bh->b_data); minix_set_bit(j, bh->b_data);
unlock_kernel(); spin_unlock(&bitmap_lock);
mark_buffer_dirty(bh); mark_buffer_dirty(bh);
j += i * bits_per_zone + sbi->s_firstdatazone-1; j += i * bits_per_zone + sbi->s_firstdatazone-1;
if (j < sbi->s_firstdatazone || j >= sbi->s_nzones) if (j < sbi->s_firstdatazone || j >= sbi->s_nzones)
break; break;
return j; return j;
} }
unlock_kernel(); spin_unlock(&bitmap_lock);
} }
return 0; return 0;
} }
@ -211,10 +212,10 @@ void minix_free_inode(struct inode * inode)
minix_clear_inode(inode); /* clear on-disk copy */ minix_clear_inode(inode); /* clear on-disk copy */
bh = sbi->s_imap[ino]; bh = sbi->s_imap[ino];
lock_kernel(); spin_lock(&bitmap_lock);
if (!minix_test_and_clear_bit(bit, bh->b_data)) if (!minix_test_and_clear_bit(bit, bh->b_data))
printk("minix_free_inode: bit %lu already cleared\n", bit); printk("minix_free_inode: bit %lu already cleared\n", bit);
unlock_kernel(); spin_unlock(&bitmap_lock);
mark_buffer_dirty(bh); mark_buffer_dirty(bh);
out: out:
clear_inode(inode); /* clear in-memory copy */ 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; j = bits_per_zone;
bh = NULL; bh = NULL;
*error = -ENOSPC; *error = -ENOSPC;
lock_kernel(); spin_lock(&bitmap_lock);
for (i = 0; i < sbi->s_imap_blocks; i++) { for (i = 0; i < sbi->s_imap_blocks; i++) {
bh = sbi->s_imap[i]; bh = sbi->s_imap[i];
j = minix_find_first_zero_bit(bh->b_data, bits_per_zone); 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; break;
} }
if (!bh || j >= bits_per_zone) { if (!bh || j >= bits_per_zone) {
unlock_kernel(); spin_unlock(&bitmap_lock);
iput(inode); iput(inode);
return NULL; return NULL;
} }
if (minix_test_and_set_bit(j, bh->b_data)) { /* shouldn't happen */ 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"); printk("minix_new_inode: bit already set\n");
iput(inode); iput(inode);
return NULL; return NULL;
} }
unlock_kernel(); spin_unlock(&bitmap_lock);
mark_buffer_dirty(bh); mark_buffer_dirty(bh);
j += i * bits_per_zone; j += i * bits_per_zone;
if (!j || j > sbi->s_ninodes) { if (!j || j > sbi->s_ninodes) {

5
fs/minix/dir.c
View file

@ -11,7 +11,6 @@
#include "minix.h" #include "minix.h"
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#include <linux/highmem.h> #include <linux/highmem.h>
#include <linux/smp_lock.h>
#include <linux/swap.h> #include <linux/swap.h>
typedef struct minix_dir_entry minix_dirent; 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); static int minix_readdir(struct file *, void *, filldir_t);
const struct file_operations minix_dir_operations = { const struct file_operations minix_dir_operations = {
.llseek = generic_file_llseek,
.read = generic_read_dir, .read = generic_read_dir,
.readdir = minix_readdir, .readdir = minix_readdir,
.fsync = simple_fsync, .fsync = simple_fsync,
@ -102,8 +102,6 @@ static int minix_readdir(struct file * filp, void * dirent, filldir_t filldir)
char *name; char *name;
__u32 inumber; __u32 inumber;
lock_kernel();
pos = (pos + chunk_size-1) & ~(chunk_size-1); pos = (pos + chunk_size-1) & ~(chunk_size-1);
if (pos >= inode->i_size) if (pos >= inode->i_size)
goto done; goto done;
@ -146,7 +144,6 @@ static int minix_readdir(struct file * filp, void * dirent, filldir_t filldir)
done: done:
filp->f_pos = (n << PAGE_CACHE_SHIFT) | offset; filp->f_pos = (n << PAGE_CACHE_SHIFT) | offset;
unlock_kernel();
return 0; return 0;
} }

4
fs/minix/inode.c
View file

@ -35,8 +35,6 @@ static void minix_put_super(struct super_block *sb)
int i; int i;
struct minix_sb_info *sbi = minix_sb(sb); struct minix_sb_info *sbi = minix_sb(sb);
lock_kernel();
if (!(sb->s_flags & MS_RDONLY)) { if (!(sb->s_flags & MS_RDONLY)) {
if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */ if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
sbi->s_ms->s_state = sbi->s_mount_state; 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); kfree(sbi->s_imap);
sb->s_fs_info = NULL; sb->s_fs_info = NULL;
kfree(sbi); kfree(sbi);
unlock_kernel();
} }
static struct kmem_cache * minix_inode_cachep; static struct kmem_cache * minix_inode_cachep;