Darkangeel_hd
/
lineage_android_kernel_xiaomi_sdm845
mirror of https://github.com/Darkangeel-hd/lineage_android_kernel_xiaomi_sdm845.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Merge branch 'trivial' of git://git.kernel.org/pub/scm/linux/kernel/git/arnd/bkl 

* 'trivial' of git://git.kernel.org/pub/scm/linux/kernel/git/arnd/bkl:
  block: autoconvert trivial BKL users to private mutex
  drivers: autoconvert trivial BKL users to private mutex
  ipmi: autoconvert trivial BKL users to private mutex
  mac: autoconvert trivial BKL users to private mutex
  mtd: autoconvert trivial BKL users to private mutex
  scsi: autoconvert trivial BKL users to private mutex

Fix up trivial conflicts (due to addition of private mutex right next to
deletion of a version string) in drivers/char/pcmcia/cm40[04]0_cs.c
This commit is contained in:
Linus Torvalds 2010-10-22 10:49:54 -07:00
parent 5704e44d28 2a48fc0ab2
commit c37927d435
100 changed files with 614 additions and 556 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
block/bsg.c
View File

@ -20,7 +20,6 @@
#include <linux/uio.h> #include <linux/uio.h>
#include <linux/idr.h> #include <linux/idr.h>
#include <linux/bsg.h> #include <linux/bsg.h>
#include <linux/smp_lock.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <scsi/scsi.h> #include <scsi/scsi.h>
@ -843,9 +842,7 @@ static int bsg_open(struct inode *inode, struct file *file)
{ {
struct bsg_device *bd; struct bsg_device *bd;
lock_kernel();
bd = bsg_get_device(inode, file); bd = bsg_get_device(inode, file);
unlock_kernel();
if (IS_ERR(bd)) if (IS_ERR(bd))
return PTR_ERR(bd); return PTR_ERR(bd);

11
drivers/block/DAC960.c
View File

@ -36,7 +36,7 @@
#include <linux/ioport.h> #include <linux/ioport.h>
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/reboot.h> #include <linux/reboot.h>
@ -54,6 +54,7 @@
#define DAC960_GAM_MINOR 252 #define DAC960_GAM_MINOR 252
static DEFINE_MUTEX(DAC960_mutex);
static DAC960_Controller_T *DAC960_Controllers[DAC960_MaxControllers]; static DAC960_Controller_T *DAC960_Controllers[DAC960_MaxControllers];
static int DAC960_ControllerCount; static int DAC960_ControllerCount;
static struct proc_dir_entry *DAC960_ProcDirectoryEntry; static struct proc_dir_entry *DAC960_ProcDirectoryEntry;
@ -81,7 +82,7 @@ static int DAC960_open(struct block_device *bdev, fmode_t mode)
int drive_nr = (long)disk->private_data; int drive_nr = (long)disk->private_data;
int ret = -ENXIO; int ret = -ENXIO;
lock_kernel(); mutex_lock(&DAC960_mutex);
if (p->FirmwareType == DAC960_V1_Controller) { if (p->FirmwareType == DAC960_V1_Controller) {
if (p->V1.LogicalDriveInformation[drive_nr]. if (p->V1.LogicalDriveInformation[drive_nr].
LogicalDriveState == DAC960_V1_LogicalDrive_Offline) LogicalDriveState == DAC960_V1_LogicalDrive_Offline)
@ -99,7 +100,7 @@ static int DAC960_open(struct block_device *bdev, fmode_t mode)
goto out; goto out;
ret = 0; ret = 0;
out: out:
unlock_kernel(); mutex_unlock(&DAC960_mutex);
return ret; return ret;
} }
@ -6625,7 +6626,7 @@ static long DAC960_gam_ioctl(struct file *file, unsigned int Request,
long ErrorCode = 0; long ErrorCode = 0;
if (!capable(CAP_SYS_ADMIN)) return -EACCES; if (!capable(CAP_SYS_ADMIN)) return -EACCES;
lock_kernel(); mutex_lock(&DAC960_mutex);
switch (Request) switch (Request)
{ {
case DAC960_IOCTL_GET_CONTROLLER_COUNT: case DAC960_IOCTL_GET_CONTROLLER_COUNT:
@ -7056,7 +7057,7 @@ static long DAC960_gam_ioctl(struct file *file, unsigned int Request,
default: default:
ErrorCode = -ENOTTY; ErrorCode = -ENOTTY;
} }
unlock_kernel(); mutex_unlock(&DAC960_mutex);
return ErrorCode; return ErrorCode;
} }

19
drivers/block/amiflop.c
View File

@ -60,7 +60,7 @@
#include <linux/hdreg.h> #include <linux/hdreg.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/amifdreg.h> #include <linux/amifdreg.h>
#include <linux/amifd.h> #include <linux/amifd.h>
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
@ -109,6 +109,7 @@
#define FD_HD_3 0x55555555 /* high-density 3.5" (1760K) drive */ #define FD_HD_3 0x55555555 /* high-density 3.5" (1760K) drive */
#define FD_DD_5 0xaaaaaaaa /* double-density 5.25" (440K) drive */ #define FD_DD_5 0xaaaaaaaa /* double-density 5.25" (440K) drive */
static DEFINE_MUTEX(amiflop_mutex);
static unsigned long int fd_def_df0 = FD_DD_3; /* default for df0 if it doesn't identify */ static unsigned long int fd_def_df0 = FD_DD_3; /* default for df0 if it doesn't identify */
module_param(fd_def_df0, ulong, 0); module_param(fd_def_df0, ulong, 0);
@ -1506,9 +1507,9 @@ static int fd_ioctl(struct block_device *bdev, fmode_t mode,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&amiflop_mutex);
ret = fd_locked_ioctl(bdev, mode, cmd, param); ret = fd_locked_ioctl(bdev, mode, cmd, param);
unlock_kernel(); mutex_unlock(&amiflop_mutex);
return ret; return ret;
} }
@ -1555,11 +1556,11 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
int old_dev; int old_dev;
unsigned long flags; unsigned long flags;
lock_kernel(); mutex_lock(&amiflop_mutex);
old_dev = fd_device[drive]; old_dev = fd_device[drive];
if (fd_ref[drive] && old_dev != system) { if (fd_ref[drive] && old_dev != system) {
unlock_kernel(); mutex_unlock(&amiflop_mutex);
return -EBUSY; return -EBUSY;
} }
@ -1575,7 +1576,7 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
rel_fdc(); rel_fdc();
if (wrprot) { if (wrprot) {
unlock_kernel(); mutex_unlock(&amiflop_mutex);
return -EROFS; return -EROFS;
} }
} }
@ -1594,7 +1595,7 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
printk(KERN_INFO "fd%d: accessing %s-disk with %s-layout\n",drive, printk(KERN_INFO "fd%d: accessing %s-disk with %s-layout\n",drive,
unit[drive].type->name, data_types[system].name); unit[drive].type->name, data_types[system].name);
unlock_kernel(); mutex_unlock(&amiflop_mutex);
return 0; return 0;
} }
@ -1603,7 +1604,7 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
struct amiga_floppy_struct *p = disk->private_data; struct amiga_floppy_struct *p = disk->private_data;
int drive = p - unit; int drive = p - unit;
lock_kernel(); mutex_lock(&amiflop_mutex);
if (unit[drive].dirty == 1) { if (unit[drive].dirty == 1) {
del_timer (flush_track_timer + drive); del_timer (flush_track_timer + drive);
non_int_flush_track (drive); non_int_flush_track (drive);
@ -1617,7 +1618,7 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
/* the mod_use counter is handled this way */ /* the mod_use counter is handled this way */
floppy_off (drive | 0x40000000); floppy_off (drive | 0x40000000);
#endif #endif
unlock_kernel(); mutex_unlock(&amiflop_mutex);
return 0; return 0;
} }

9
drivers/block/aoe/aoeblk.c
View File

@ -12,9 +12,10 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/genhd.h> #include <linux/genhd.h>
#include <linux/netdevice.h> #include <linux/netdevice.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include "aoe.h" #include "aoe.h"
static DEFINE_MUTEX(aoeblk_mutex);
static struct kmem_cache *buf_pool_cache; static struct kmem_cache *buf_pool_cache;
static ssize_t aoedisk_show_state(struct device *dev, static ssize_t aoedisk_show_state(struct device *dev,
@ -125,16 +126,16 @@ aoeblk_open(struct block_device *bdev, fmode_t mode)
struct aoedev *d = bdev->bd_disk->private_data; struct aoedev *d = bdev->bd_disk->private_data;
ulong flags; ulong flags;
lock_kernel(); mutex_lock(&aoeblk_mutex);
spin_lock_irqsave(&d->lock, flags); spin_lock_irqsave(&d->lock, flags);
if (d->flags & DEVFL_UP) { if (d->flags & DEVFL_UP) {
d->nopen++; d->nopen++;
spin_unlock_irqrestore(&d->lock, flags); spin_unlock_irqrestore(&d->lock, flags);
unlock_kernel(); mutex_unlock(&aoeblk_mutex);
return 0; return 0;
} }
spin_unlock_irqrestore(&d->lock, flags); spin_unlock_irqrestore(&d->lock, flags);
unlock_kernel(); mutex_unlock(&aoeblk_mutex);
return -ENODEV; return -ENODEV;
} }

9
drivers/block/aoe/aoechr.c
View File

@ -9,7 +9,7 @@
#include <linux/completion.h> #include <linux/completion.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/skbuff.h> #include <linux/skbuff.h>
#include "aoe.h" #include "aoe.h"
@ -37,6 +37,7 @@ struct ErrMsg {
char *msg; char *msg;
}; };
static DEFINE_MUTEX(aoechr_mutex);
static struct ErrMsg emsgs[NMSG]; static struct ErrMsg emsgs[NMSG];
static int emsgs_head_idx, emsgs_tail_idx; static int emsgs_head_idx, emsgs_tail_idx;
static struct completion emsgs_comp; static struct completion emsgs_comp;
@ -183,16 +184,16 @@ aoechr_open(struct inode *inode, struct file *filp)
{ {
int n, i; int n, i;
lock_kernel(); mutex_lock(&aoechr_mutex);
n = iminor(inode); n = iminor(inode);
filp->private_data = (void *) (unsigned long) n; filp->private_data = (void *) (unsigned long) n;
for (i = 0; i < ARRAY_SIZE(chardevs); ++i) for (i = 0; i < ARRAY_SIZE(chardevs); ++i)
if (chardevs[i].minor == n) { if (chardevs[i].minor == n) {
unlock_kernel(); mutex_unlock(&aoechr_mutex);
return 0; return 0;
} }
unlock_kernel(); mutex_unlock(&aoechr_mutex);
return -EINVAL; return -EINVAL;
} }

15
drivers/block/ataflop.c
View File

@ -67,7 +67,7 @@
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <asm/atafd.h> #include <asm/atafd.h>
#include <asm/atafdreg.h> #include <asm/atafdreg.h>
@ -79,6 +79,7 @@
#undef DEBUG #undef DEBUG
static DEFINE_MUTEX(ataflop_mutex);
static struct request_queue *floppy_queue; static struct request_queue *floppy_queue;
static struct request *fd_request; static struct request *fd_request;
@ -1671,9 +1672,9 @@ static int fd_ioctl(struct block_device *bdev, fmode_t mode,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&ataflop_mutex);
ret = fd_locked_ioctl(bdev, mode, cmd, arg); ret = fd_locked_ioctl(bdev, mode, cmd, arg);
unlock_kernel(); mutex_unlock(&ataflop_mutex);
return ret; return ret;
} }
@ -1854,9 +1855,9 @@ static int floppy_unlocked_open(struct block_device *bdev, fmode_t mode)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&ataflop_mutex);
ret = floppy_open(bdev, mode); ret = floppy_open(bdev, mode);
unlock_kernel(); mutex_unlock(&ataflop_mutex);
return ret; return ret;
} }
@ -1864,14 +1865,14 @@ static int floppy_unlocked_open(struct block_device *bdev, fmode_t mode)
static int floppy_release(struct gendisk *disk, fmode_t mode) static int floppy_release(struct gendisk *disk, fmode_t mode)
{ {
struct atari_floppy_struct *p = disk->private_data; struct atari_floppy_struct *p = disk->private_data;
lock_kernel(); mutex_lock(&ataflop_mutex);
if (p->ref < 0) if (p->ref < 0)
p->ref = 0; p->ref = 0;
else if (!p->ref--) { else if (!p->ref--) {
printk(KERN_ERR "floppy_release with fd_ref == 0"); printk(KERN_ERR "floppy_release with fd_ref == 0");
p->ref = 0; p->ref = 0;
} }
unlock_kernel(); mutex_unlock(&ataflop_mutex);
return 0; return 0;
} }

7
drivers/block/brd.c
View File

@ -15,7 +15,7 @@
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/bio.h> #include <linux/bio.h>
#include <linux/highmem.h> #include <linux/highmem.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/radix-tree.h> #include <linux/radix-tree.h>
#include <linux/buffer_head.h> /* invalidate_bh_lrus() */ #include <linux/buffer_head.h> /* invalidate_bh_lrus() */
#include <linux/slab.h> #include <linux/slab.h>
@ -55,6 +55,7 @@ struct brd_device {
/* /*
* Look up and return a brd's page for a given sector. * Look up and return a brd's page for a given sector.
*/ */
static DEFINE_MUTEX(brd_mutex);
static struct page *brd_lookup_page(struct brd_device *brd, sector_t sector) static struct page *brd_lookup_page(struct brd_device *brd, sector_t sector)
{ {
pgoff_t idx; pgoff_t idx;
@ -402,7 +403,7 @@ static int brd_ioctl(struct block_device *bdev, fmode_t mode,
* ram device BLKFLSBUF has special semantics, we want to actually * ram device BLKFLSBUF has special semantics, we want to actually
* release and destroy the ramdisk data. * release and destroy the ramdisk data.
*/ */
lock_kernel(); mutex_lock(&brd_mutex);
mutex_lock(&bdev->bd_mutex); mutex_lock(&bdev->bd_mutex);
error = -EBUSY; error = -EBUSY;
if (bdev->bd_openers <= 1) { if (bdev->bd_openers <= 1) {
@ -419,7 +420,7 @@ static int brd_ioctl(struct block_device *bdev, fmode_t mode,
error = 0; error = 0;
} }
mutex_unlock(&bdev->bd_mutex); mutex_unlock(&bdev->bd_mutex);
unlock_kernel(); mutex_unlock(&brd_mutex);
return error; return error;
} }

14
drivers/block/cciss.c
View File

@ -26,7 +26,6 @@
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp_lock.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/major.h> #include <linux/major.h>
#include <linux/fs.h> #include <linux/fs.h>
@ -66,6 +65,7 @@ MODULE_SUPPORTED_DEVICE("HP Smart Array Controllers");
MODULE_VERSION("3.6.26"); MODULE_VERSION("3.6.26");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
static DEFINE_MUTEX(cciss_mutex);
static int cciss_allow_hpsa; static int cciss_allow_hpsa;
module_param(cciss_allow_hpsa, int, S_IRUGO|S_IWUSR); module_param(cciss_allow_hpsa, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(cciss_allow_hpsa, MODULE_PARM_DESC(cciss_allow_hpsa,
@ -1059,9 +1059,9 @@ static int cciss_unlocked_open(struct block_device *bdev, fmode_t mode)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&cciss_mutex);
ret = cciss_open(bdev, mode); ret = cciss_open(bdev, mode);
unlock_kernel(); mutex_unlock(&cciss_mutex);
return ret; return ret;
} }
@ -1074,13 +1074,13 @@ static int cciss_release(struct gendisk *disk, fmode_t mode)
ctlr_info_t *h; ctlr_info_t *h;
drive_info_struct *drv; drive_info_struct *drv;
lock_kernel(); mutex_lock(&cciss_mutex);
h = get_host(disk); h = get_host(disk);
drv = get_drv(disk); drv = get_drv(disk);
dev_dbg(&h->pdev->dev, "cciss_release %s\n", disk->disk_name); dev_dbg(&h->pdev->dev, "cciss_release %s\n", disk->disk_name);
drv->usage_count--; drv->usage_count--;
h->usage_count--; h->usage_count--;
unlock_kernel(); mutex_unlock(&cciss_mutex);
return 0; return 0;
} }
@ -1088,9 +1088,9 @@ static int do_ioctl(struct block_device *bdev, fmode_t mode,
unsigned cmd, unsigned long arg) unsigned cmd, unsigned long arg)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&cciss_mutex);
ret = cciss_ioctl(bdev, mode, cmd, arg); ret = cciss_ioctl(bdev, mode, cmd, arg);
unlock_kernel(); mutex_unlock(&cciss_mutex);
return ret; return ret;
} }

15
drivers/block/cpqarray.c
View File

@ -35,7 +35,7 @@
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/hdreg.h> #include <linux/hdreg.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/genhd.h> #include <linux/genhd.h>
@ -68,6 +68,7 @@ MODULE_LICENSE("GPL");
#define CPQARRAY_DMA_MASK 0xFFFFFFFF /* 32 bit DMA */ #define CPQARRAY_DMA_MASK 0xFFFFFFFF /* 32 bit DMA */
static DEFINE_MUTEX(cpqarray_mutex);
static int nr_ctlr; static int nr_ctlr;
static ctlr_info_t *hba[MAX_CTLR]; static ctlr_info_t *hba[MAX_CTLR];
@ -845,9 +846,9 @@ static int ida_unlocked_open(struct block_device *bdev, fmode_t mode)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&cpqarray_mutex);
ret = ida_open(bdev, mode); ret = ida_open(bdev, mode);
unlock_kernel(); mutex_unlock(&cpqarray_mutex);
return ret; return ret;
} }
@ -859,10 +860,10 @@ static int ida_release(struct gendisk *disk, fmode_t mode)
{ {
ctlr_info_t *host; ctlr_info_t *host;
lock_kernel(); mutex_lock(&cpqarray_mutex);
host = get_host(disk); host = get_host(disk);
host->usage_count--; host->usage_count--;
unlock_kernel(); mutex_unlock(&cpqarray_mutex);
return 0; return 0;
} }
@ -1217,9 +1218,9 @@ static int ida_ioctl(struct block_device *bdev, fmode_t mode,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&cpqarray_mutex);
ret = ida_locked_ioctl(bdev, mode, cmd, param); ret = ida_locked_ioctl(bdev, mode, cmd, param);
unlock_kernel(); mutex_unlock(&cpqarray_mutex);
return ret; return ret;
} }

11
drivers/block/drbd/drbd_main.c
View File

@ -32,7 +32,7 @@
#include <asm/types.h> #include <asm/types.h>
#include <net/sock.h> #include <net/sock.h>
#include <linux/ctype.h> #include <linux/ctype.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/file.h> #include <linux/file.h>
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
@ -64,6 +64,7 @@ struct after_state_chg_work {
struct completion *done; struct completion *done;
}; };
static DEFINE_MUTEX(drbd_main_mutex);
int drbdd_init(struct drbd_thread *); int drbdd_init(struct drbd_thread *);
int drbd_worker(struct drbd_thread *); int drbd_worker(struct drbd_thread *);
int drbd_asender(struct drbd_thread *); int drbd_asender(struct drbd_thread *);
@ -2536,7 +2537,7 @@ static int drbd_open(struct block_device *bdev, fmode_t mode)
unsigned long flags; unsigned long flags;
int rv = 0; int rv = 0;
lock_kernel(); mutex_lock(&drbd_main_mutex);
spin_lock_irqsave(&mdev->req_lock, flags); spin_lock_irqsave(&mdev->req_lock, flags);
/* to have a stable mdev->state.role /* to have a stable mdev->state.role
* and no race with updating open_cnt */ * and no race with updating open_cnt */
@ -2551,7 +2552,7 @@ static int drbd_open(struct block_device *bdev, fmode_t mode)
if (!rv) if (!rv)
mdev->open_cnt++; mdev->open_cnt++;
spin_unlock_irqrestore(&mdev->req_lock, flags); spin_unlock_irqrestore(&mdev->req_lock, flags);
unlock_kernel(); mutex_unlock(&drbd_main_mutex);
return rv; return rv;
} }
@ -2559,9 +2560,9 @@ static int drbd_open(struct block_device *bdev, fmode_t mode)
static int drbd_release(struct gendisk *gd, fmode_t mode) static int drbd_release(struct gendisk *gd, fmode_t mode)
{ {
struct drbd_conf *mdev = gd->private_data; struct drbd_conf *mdev = gd->private_data;
lock_kernel(); mutex_lock(&drbd_main_mutex);
mdev->open_cnt--; mdev->open_cnt--;
unlock_kernel(); mutex_unlock(&drbd_main_mutex);
return 0; return 0;
} }

16
drivers/block/floppy.c
View File

@ -178,7 +178,6 @@ static int print_unex = 1;
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/bio.h> #include <linux/bio.h>
#include <linux/smp_lock.h>
#include <linux/string.h> #include <linux/string.h>
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <linux/fcntl.h> #include <linux/fcntl.h>
@ -199,6 +198,7 @@ static int print_unex = 1;
* It's been recommended that take about 1/4 of the default speed * It's been recommended that take about 1/4 of the default speed
* in some more extreme cases. * in some more extreme cases.
*/ */
static DEFINE_MUTEX(floppy_mutex);
static int slow_floppy; static int slow_floppy;
#include <asm/dma.h> #include <asm/dma.h>
@ -3553,9 +3553,9 @@ static int fd_ioctl(struct block_device *bdev, fmode_t mode,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&floppy_mutex);
ret = fd_locked_ioctl(bdev, mode, cmd, param); ret = fd_locked_ioctl(bdev, mode, cmd, param);
unlock_kernel(); mutex_unlock(&floppy_mutex);
return ret; return ret;
} }
@ -3616,7 +3616,7 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
{ {
int drive = (long)disk->private_data; int drive = (long)disk->private_data;
lock_kernel(); mutex_lock(&floppy_mutex);
mutex_lock(&open_lock); mutex_lock(&open_lock);
if (UDRS->fd_ref < 0) if (UDRS->fd_ref < 0)
UDRS->fd_ref = 0; UDRS->fd_ref = 0;
@ -3627,7 +3627,7 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
if (!UDRS->fd_ref) if (!UDRS->fd_ref)
opened_bdev[drive] = NULL; opened_bdev[drive] = NULL;
mutex_unlock(&open_lock); mutex_unlock(&open_lock);
unlock_kernel(); mutex_unlock(&floppy_mutex);
return 0; return 0;
} }
@ -3645,7 +3645,7 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
int res = -EBUSY; int res = -EBUSY;
char *tmp; char *tmp;
lock_kernel(); mutex_lock(&floppy_mutex);
mutex_lock(&open_lock); mutex_lock(&open_lock);
old_dev = UDRS->fd_device; old_dev = UDRS->fd_device;
if (opened_bdev[drive] && opened_bdev[drive] != bdev) if (opened_bdev[drive] && opened_bdev[drive] != bdev)
@ -3722,7 +3722,7 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
goto out; goto out;
} }
mutex_unlock(&open_lock); mutex_unlock(&open_lock);
unlock_kernel(); mutex_unlock(&floppy_mutex);
return 0; return 0;
out: out:
if (UDRS->fd_ref < 0) if (UDRS->fd_ref < 0)
@ -3733,7 +3733,7 @@ out:
opened_bdev[drive] = NULL; opened_bdev[drive] = NULL;
out2: out2:
mutex_unlock(&open_lock); mutex_unlock(&open_lock);
unlock_kernel(); mutex_unlock(&floppy_mutex);
return res; return res;
} }

11
drivers/block/loop.c
View File

@ -67,7 +67,7 @@
#include <linux/compat.h> #include <linux/compat.h>
#include <linux/suspend.h> #include <linux/suspend.h>
#include <linux/freezer.h> #include <linux/freezer.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/writeback.h> #include <linux/writeback.h>
#include <linux/buffer_head.h> /* for invalidate_bdev() */ #include <linux/buffer_head.h> /* for invalidate_bdev() */
#include <linux/completion.h> #include <linux/completion.h>
@ -77,6 +77,7 @@
#include <asm/uaccess.h> #include <asm/uaccess.h>
static DEFINE_MUTEX(loop_mutex);
static LIST_HEAD(loop_devices); static LIST_HEAD(loop_devices);
static DEFINE_MUTEX(loop_devices_mutex); static DEFINE_MUTEX(loop_devices_mutex);
@ -1409,11 +1410,11 @@ static int lo_open(struct block_device *bdev, fmode_t mode)
{ {
struct loop_device *lo = bdev->bd_disk->private_data; struct loop_device *lo = bdev->bd_disk->private_data;
lock_kernel(); mutex_lock(&loop_mutex);
mutex_lock(&lo->lo_ctl_mutex); mutex_lock(&lo->lo_ctl_mutex);
lo->lo_refcnt++; lo->lo_refcnt++;
mutex_unlock(&lo->lo_ctl_mutex); mutex_unlock(&lo->lo_ctl_mutex);
unlock_kernel(); mutex_unlock(&loop_mutex);
return 0; return 0;
} }
@ -1423,7 +1424,7 @@ static int lo_release(struct gendisk *disk, fmode_t mode)
struct loop_device *lo = disk->private_data; struct loop_device *lo = disk->private_data;
int err; int err;
lock_kernel(); mutex_lock(&loop_mutex);
mutex_lock(&lo->lo_ctl_mutex); mutex_lock(&lo->lo_ctl_mutex);
if (--lo->lo_refcnt) if (--lo->lo_refcnt)
@ -1448,7 +1449,7 @@ static int lo_release(struct gendisk *disk, fmode_t mode)
out: out:
mutex_unlock(&lo->lo_ctl_mutex); mutex_unlock(&lo->lo_ctl_mutex);
out_unlocked: out_unlocked:
lock_kernel(); mutex_unlock(&loop_mutex);
return 0; return 0;
} }

7
drivers/block/nbd.c
View File

@ -24,7 +24,7 @@
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/file.h> #include <linux/file.h>
#include <linux/ioctl.h> #include <linux/ioctl.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/compiler.h> #include <linux/compiler.h>
#include <linux/err.h> #include <linux/err.h>
#include <linux/kernel.h> #include <linux/kernel.h>
@ -53,6 +53,7 @@
#define DBG_BLKDEV 0x0100 #define DBG_BLKDEV 0x0100
#define DBG_RX 0x0200 #define DBG_RX 0x0200
#define DBG_TX 0x0400 #define DBG_TX 0x0400
static DEFINE_MUTEX(nbd_mutex);
static unsigned int debugflags; static unsigned int debugflags;
#endif /* NDEBUG */ #endif /* NDEBUG */
@ -717,11 +718,11 @@ static int nbd_ioctl(struct block_device *bdev, fmode_t mode,
dprintk(DBG_IOCTL, "%s: nbd_ioctl cmd=%s(0x%x) arg=%lu\n", dprintk(DBG_IOCTL, "%s: nbd_ioctl cmd=%s(0x%x) arg=%lu\n",
lo->disk->disk_name, ioctl_cmd_to_ascii(cmd), cmd, arg); lo->disk->disk_name, ioctl_cmd_to_ascii(cmd), cmd, arg);
lock_kernel(); mutex_lock(&nbd_mutex);
mutex_lock(&lo->tx_lock); mutex_lock(&lo->tx_lock);
error = __nbd_ioctl(bdev, lo, cmd, arg); error = __nbd_ioctl(bdev, lo, cmd, arg);
mutex_unlock(&lo->tx_lock); mutex_unlock(&lo->tx_lock);
unlock_kernel(); mutex_unlock(&nbd_mutex);
return error; return error;
} }

15
drivers/block/paride/pcd.c
View File

@ -138,9 +138,10 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_DLY};
#include <linux/cdrom.h> #include <linux/cdrom.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
static DEFINE_MUTEX(pcd_mutex);
static DEFINE_SPINLOCK(pcd_lock); static DEFINE_SPINLOCK(pcd_lock);
module_param(verbose, bool, 0644); module_param(verbose, bool, 0644);
@ -227,9 +228,9 @@ static int pcd_block_open(struct block_device *bdev, fmode_t mode)
struct pcd_unit *cd = bdev->bd_disk->private_data; struct pcd_unit *cd = bdev->bd_disk->private_data;
int ret; int ret;
lock_kernel(); mutex_lock(&pcd_mutex);
ret = cdrom_open(&cd->info, bdev, mode); ret = cdrom_open(&cd->info, bdev, mode);
unlock_kernel(); mutex_unlock(&pcd_mutex);
return ret; return ret;
} }
@ -237,9 +238,9 @@ static int pcd_block_open(struct block_device *bdev, fmode_t mode)
static int pcd_block_release(struct gendisk *disk, fmode_t mode) static int pcd_block_release(struct gendisk *disk, fmode_t mode)
{ {
struct pcd_unit *cd = disk->private_data; struct pcd_unit *cd = disk->private_data;
lock_kernel(); mutex_lock(&pcd_mutex);
cdrom_release(&cd->info, mode); cdrom_release(&cd->info, mode);
unlock_kernel(); mutex_unlock(&pcd_mutex);
return 0; return 0;
} }
@ -249,9 +250,9 @@ static int pcd_block_ioctl(struct block_device *bdev, fmode_t mode,
struct pcd_unit *cd = bdev->bd_disk->private_data; struct pcd_unit *cd = bdev->bd_disk->private_data;
int ret; int ret;
lock_kernel(); mutex_lock(&pcd_mutex);
ret = cdrom_ioctl(&cd->info, bdev, mode, cmd, arg); ret = cdrom_ioctl(&cd->info, bdev, mode, cmd, arg);
unlock_kernel(); mutex_unlock(&pcd_mutex);
return ret; return ret;
} }

15
drivers/block/paride/pd.c
View File

@ -153,10 +153,11 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_GEO, D_SBY, D_DLY, D_SLV};
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/blkpg.h> #include <linux/blkpg.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
#include <linux/workqueue.h> #include <linux/workqueue.h>
static DEFINE_MUTEX(pd_mutex);
static DEFINE_SPINLOCK(pd_lock); static DEFINE_SPINLOCK(pd_lock);
module_param(verbose, bool, 0); module_param(verbose, bool, 0);
@ -736,14 +737,14 @@ static int pd_open(struct block_device *bdev, fmode_t mode)
{ {
struct pd_unit *disk = bdev->bd_disk->private_data; struct pd_unit *disk = bdev->bd_disk->private_data;
lock_kernel(); mutex_lock(&pd_mutex);
disk->access++; disk->access++;
if (disk->removable) { if (disk->removable) {
pd_special_command(disk, pd_media_check); pd_special_command(disk, pd_media_check);
pd_special_command(disk, pd_door_lock); pd_special_command(disk, pd_door_lock);
} }
unlock_kernel(); mutex_unlock(&pd_mutex);
return 0; return 0;
} }
@ -771,10 +772,10 @@ static int pd_ioctl(struct block_device *bdev, fmode_t mode,
switch (cmd) { switch (cmd) {
case CDROMEJECT: case CDROMEJECT:
lock_kernel(); mutex_lock(&pd_mutex);
if (disk->access == 1) if (disk->access == 1)
pd_special_command(disk, pd_eject); pd_special_command(disk, pd_eject);
unlock_kernel(); mutex_unlock(&pd_mutex);
return 0; return 0;
default: default:
return -EINVAL; return -EINVAL;
@ -785,10 +786,10 @@ static int pd_release(struct gendisk *p, fmode_t mode)
{ {
struct pd_unit *disk = p->private_data; struct pd_unit *disk = p->private_data;
lock_kernel(); mutex_lock(&pd_mutex);
if (!--disk->access && disk->removable) if (!--disk->access && disk->removable)
pd_special_command(disk, pd_door_unlock); pd_special_command(disk, pd_door_unlock);
unlock_kernel(); mutex_unlock(&pd_mutex);
return 0; return 0;
} }

17
drivers/block/paride/pf.c
View File

@ -152,9 +152,10 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_LUN, D_DLY};
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/blkpg.h> #include <linux/blkpg.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
static DEFINE_MUTEX(pf_mutex);
static DEFINE_SPINLOCK(pf_spin_lock); static DEFINE_SPINLOCK(pf_spin_lock);
module_param(verbose, bool, 0644); module_param(verbose, bool, 0644);
@ -302,7 +303,7 @@ static int pf_open(struct block_device *bdev, fmode_t mode)
struct pf_unit *pf = bdev->bd_disk->private_data; struct pf_unit *pf = bdev->bd_disk->private_data;
int ret; int ret;
lock_kernel(); mutex_lock(&pf_mutex);
pf_identify(pf); pf_identify(pf);
ret = -ENODEV; ret = -ENODEV;
@ -318,7 +319,7 @@ static int pf_open(struct block_device *bdev, fmode_t mode)
if (pf->removable) if (pf->removable)
pf_lock(pf, 1); pf_lock(pf, 1);
out: out:
unlock_kernel(); mutex_unlock(&pf_mutex);
return ret; return ret;
} }
@ -349,9 +350,9 @@ static int pf_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, u
if (pf->access != 1) if (pf->access != 1)
return -EBUSY; return -EBUSY;
lock_kernel(); mutex_lock(&pf_mutex);
pf_eject(pf); pf_eject(pf);
unlock_kernel(); mutex_unlock(&pf_mutex);
return 0; return 0;
} }
@ -360,9 +361,9 @@ static int pf_release(struct gendisk *disk, fmode_t mode)
{ {
struct pf_unit *pf = disk->private_data; struct pf_unit *pf = disk->private_data;
lock_kernel(); mutex_lock(&pf_mutex);
if (pf->access <= 0) { if (pf->access <= 0) {
unlock_kernel(); mutex_unlock(&pf_mutex);
return -EINVAL; return -EINVAL;
} }
@ -371,7 +372,7 @@ static int pf_release(struct gendisk *disk, fmode_t mode)
if (!pf->access && pf->removable) if (!pf->access && pf->removable)
pf_lock(pf, 0); pf_lock(pf, 0);
unlock_kernel(); mutex_unlock(&pf_mutex);
return 0; return 0;
} }

7
drivers/block/paride/pg.c
View File

@ -162,7 +162,7 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_DLY};
#include <linux/pg.h> #include <linux/pg.h>
#include <linux/device.h> #include <linux/device.h>
#include <linux/sched.h> /* current, TASK_* */ #include <linux/sched.h> /* current, TASK_* */
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
@ -193,6 +193,7 @@ module_param_array(drive3, int, NULL, 0);
#define ATAPI_IDENTIFY 0x12 #define ATAPI_IDENTIFY 0x12
static DEFINE_MUTEX(pg_mutex);
static int pg_open(struct inode *inode, struct file *file); static int pg_open(struct inode *inode, struct file *file);
static int pg_release(struct inode *inode, struct file *file); static int pg_release(struct inode *inode, struct file *file);
static ssize_t pg_read(struct file *filp, char __user *buf, static ssize_t pg_read(struct file *filp, char __user *buf,
@ -518,7 +519,7 @@ static int pg_open(struct inode *inode, struct file *file)
struct pg *dev = &devices[unit]; struct pg *dev = &devices[unit];
int ret = 0; int ret = 0;
lock_kernel(); mutex_lock(&pg_mutex);
if ((unit >= PG_UNITS) || (!dev->present)) { if ((unit >= PG_UNITS) || (!dev->present)) {
ret = -ENODEV; ret = -ENODEV;
goto out; goto out;
@ -547,7 +548,7 @@ static int pg_open(struct inode *inode, struct file *file)
file->private_data = dev; file->private_data = dev;
out: out:
unlock_kernel(); mutex_unlock(&pg_mutex);
return ret; return ret;
} }

19
drivers/block/paride/pt.c
View File

@ -146,7 +146,7 @@ static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3};
#include <linux/mtio.h> #include <linux/mtio.h>
#include <linux/device.h> #include <linux/device.h>
#include <linux/sched.h> /* current, TASK_*, schedule_timeout() */ #include <linux/sched.h> /* current, TASK_*, schedule_timeout() */
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
@ -189,6 +189,7 @@ module_param_array(drive3, int, NULL, 0);
#define ATAPI_MODE_SENSE 0x1a #define ATAPI_MODE_SENSE 0x1a
#define ATAPI_LOG_SENSE 0x4d #define ATAPI_LOG_SENSE 0x4d
static DEFINE_MUTEX(pt_mutex);
static int pt_open(struct inode *inode, struct file *file); static int pt_open(struct inode *inode, struct file *file);
static long pt_ioctl(struct file *file, unsigned int cmd, unsigned long arg); static long pt_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
static int pt_release(struct inode *inode, struct file *file); static int pt_release(struct inode *inode, struct file *file);
@ -650,9 +651,9 @@ static int pt_open(struct inode *inode, struct file *file)
struct pt_unit *tape = pt + unit; struct pt_unit *tape = pt + unit;
int err; int err;
lock_kernel(); mutex_lock(&pt_mutex);
if (unit >= PT_UNITS || (!tape->present)) { if (unit >= PT_UNITS || (!tape->present)) {
unlock_kernel(); mutex_unlock(&pt_mutex);
return -ENODEV; return -ENODEV;
} }
@ -681,12 +682,12 @@ static int pt_open(struct inode *inode, struct file *file)
} }
file->private_data = tape; file->private_data = tape;
unlock_kernel(); mutex_unlock(&pt_mutex);
return 0; return 0;
out: out:
atomic_inc(&tape->available); atomic_inc(&tape->available);
unlock_kernel(); mutex_unlock(&pt_mutex);
return err; return err;
} }
@ -704,15 +705,15 @@ static long pt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
switch (mtop.mt_op) { switch (mtop.mt_op) {
case MTREW: case MTREW:
lock_kernel(); mutex_lock(&pt_mutex);
pt_rewind(tape); pt_rewind(tape);
unlock_kernel(); mutex_unlock(&pt_mutex);
return 0; return 0;
case MTWEOF: case MTWEOF:
lock_kernel(); mutex_lock(&pt_mutex);
pt_write_fm(tape); pt_write_fm(tape);
unlock_kernel(); mutex_unlock(&pt_mutex);
return 0; return 0;
default: default:

16
drivers/block/pktcdvd.c
View File

@ -57,7 +57,6 @@
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/miscdevice.h> #include <linux/miscdevice.h>
#include <linux/freezer.h> #include <linux/freezer.h>
#include <linux/smp_lock.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <scsi/scsi_cmnd.h> #include <scsi/scsi_cmnd.h>
@ -86,6 +85,7 @@
#define ZONE(sector, pd) (((sector) + (pd)->offset) & ~((pd)->settings.size - 1)) #define ZONE(sector, pd) (((sector) + (pd)->offset) & ~((pd)->settings.size - 1))
static DEFINE_MUTEX(pktcdvd_mutex);
static struct pktcdvd_device *pkt_devs[MAX_WRITERS]; static struct pktcdvd_device *pkt_devs[MAX_WRITERS];
static struct proc_dir_entry *pkt_proc; static struct proc_dir_entry *pkt_proc;
static int pktdev_major; static int pktdev_major;
@ -2383,7 +2383,7 @@ static int pkt_open(struct block_device *bdev, fmode_t mode)
VPRINTK(DRIVER_NAME": entering open\n"); VPRINTK(DRIVER_NAME": entering open\n");
lock_kernel(); mutex_lock(&pktcdvd_mutex);
mutex_lock(&ctl_mutex); mutex_lock(&ctl_mutex);
pd = pkt_find_dev_from_minor(MINOR(bdev->bd_dev)); pd = pkt_find_dev_from_minor(MINOR(bdev->bd_dev));
if (!pd) { if (!pd) {
@ -2411,7 +2411,7 @@ static int pkt_open(struct block_device *bdev, fmode_t mode)
} }
mutex_unlock(&ctl_mutex); mutex_unlock(&ctl_mutex);
unlock_kernel(); mutex_unlock(&pktcdvd_mutex);
return 0; return 0;
out_dec: out_dec:
@ -2419,7 +2419,7 @@ out_dec:
out: out:
VPRINTK(DRIVER_NAME": failed open (%d)\n", ret); VPRINTK(DRIVER_NAME": failed open (%d)\n", ret);
mutex_unlock(&ctl_mutex); mutex_unlock(&ctl_mutex);
unlock_kernel(); mutex_unlock(&pktcdvd_mutex);
return ret; return ret;
} }
@ -2428,7 +2428,7 @@ static int pkt_close(struct gendisk *disk, fmode_t mode)
struct pktcdvd_device *pd = disk->private_data; struct pktcdvd_device *pd = disk->private_data;
int ret = 0; int ret = 0;
lock_kernel(); mutex_lock(&pktcdvd_mutex);
mutex_lock(&ctl_mutex); mutex_lock(&ctl_mutex);
pd->refcnt--; pd->refcnt--;
BUG_ON(pd->refcnt < 0); BUG_ON(pd->refcnt < 0);
@ -2437,7 +2437,7 @@ static int pkt_close(struct gendisk *disk, fmode_t mode)
pkt_release_dev(pd, flush); pkt_release_dev(pd, flush);
} }
mutex_unlock(&ctl_mutex); mutex_unlock(&ctl_mutex);
unlock_kernel(); mutex_unlock(&pktcdvd_mutex);
return ret; return ret;
} }
@ -2773,7 +2773,7 @@ static int pkt_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
VPRINTK("pkt_ioctl: cmd %x, dev %d:%d\n", cmd, VPRINTK("pkt_ioctl: cmd %x, dev %d:%d\n", cmd,
MAJOR(bdev->bd_dev), MINOR(bdev->bd_dev)); MAJOR(bdev->bd_dev), MINOR(bdev->bd_dev));
lock_kernel(); mutex_lock(&pktcdvd_mutex);
switch (cmd) { switch (cmd) {
case CDROMEJECT: case CDROMEJECT:
/* /*
@ -2798,7 +2798,7 @@ static int pkt_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
VPRINTK(DRIVER_NAME": Unknown ioctl for %s (%x)\n", pd->name, cmd); VPRINTK(DRIVER_NAME": Unknown ioctl for %s (%x)\n", pd->name, cmd);
ret = -ENOTTY; ret = -ENOTTY;
} }
unlock_kernel(); mutex_unlock(&pktcdvd_mutex);
return ret; return ret;
} }

15
drivers/block/swim.c
View File

@ -20,7 +20,7 @@
#include <linux/fd.h> #include <linux/fd.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/hdreg.h> #include <linux/hdreg.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/delay.h> #include <linux/delay.h>
@ -222,6 +222,7 @@ extern int swim_read_sector_header(struct swim __iomem *base,
extern int swim_read_sector_data(struct swim __iomem *base, extern int swim_read_sector_data(struct swim __iomem *base,
unsigned char *data); unsigned char *data);
static DEFINE_MUTEX(swim_mutex);
static inline void set_swim_mode(struct swim __iomem *base, int enable) static inline void set_swim_mode(struct swim __iomem *base, int enable)
{ {
struct iwm __iomem *iwm_base; struct iwm __iomem *iwm_base;
@ -666,9 +667,9 @@ static int floppy_unlocked_open(struct block_device *bdev, fmode_t mode)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&swim_mutex);
ret = floppy_open(bdev, mode); ret = floppy_open(bdev, mode);
unlock_kernel(); mutex_unlock(&swim_mutex);
return ret; return ret;
} }
@ -678,7 +679,7 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
struct floppy_state *fs = disk->private_data; struct floppy_state *fs = disk->private_data;
struct swim __iomem *base = fs->swd->base; struct swim __iomem *base = fs->swd->base;
lock_kernel(); mutex_lock(&swim_mutex);
if (fs->ref_count < 0) if (fs->ref_count < 0)
fs->ref_count = 0; fs->ref_count = 0;
else if (fs->ref_count > 0) else if (fs->ref_count > 0)
@ -686,7 +687,7 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
if (fs->ref_count == 0) if (fs->ref_count == 0)
swim_motor(base, OFF); swim_motor(base, OFF);
unlock_kernel(); mutex_unlock(&swim_mutex);
return 0; return 0;
} }
@ -704,9 +705,9 @@ static int floppy_ioctl(struct block_device *bdev, fmode_t mode,
case FDEJECT: case FDEJECT:
if (fs->ref_count != 1) if (fs->ref_count != 1)
return -EBUSY; return -EBUSY;
lock_kernel(); mutex_lock(&swim_mutex);
err = floppy_eject(fs); err = floppy_eject(fs);
unlock_kernel(); mutex_unlock(&swim_mutex);
return err; return err;
case FDGETPRM: case FDGETPRM:

15
drivers/block/swim3.c
View File

@ -25,7 +25,7 @@
#include <linux/ioctl.h> #include <linux/ioctl.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <asm/io.h> #include <asm/io.h>
@ -36,6 +36,7 @@
#include <asm/machdep.h> #include <asm/machdep.h>
#include <asm/pmac_feature.h> #include <asm/pmac_feature.h>
static DEFINE_MUTEX(swim3_mutex);
static struct request_queue *swim3_queue; static struct request_queue *swim3_queue;
static struct gendisk *disks[2]; static struct gendisk *disks[2];
static struct request *fd_req; static struct request *fd_req;
@ -873,9 +874,9 @@ static int floppy_ioctl(struct block_device *bdev, fmode_t mode,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&swim3_mutex);
ret = floppy_locked_ioctl(bdev, mode, cmd, param); ret = floppy_locked_ioctl(bdev, mode, cmd, param);
unlock_kernel(); mutex_unlock(&swim3_mutex);
return ret; return ret;
} }
@ -953,9 +954,9 @@ static int floppy_unlocked_open(struct block_device *bdev, fmode_t mode)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&swim3_mutex);
ret = floppy_open(bdev, mode); ret = floppy_open(bdev, mode);
unlock_kernel(); mutex_unlock(&swim3_mutex);
return ret; return ret;
} }
@ -964,13 +965,13 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
{ {
struct floppy_state *fs = disk->private_data; struct floppy_state *fs = disk->private_data;
struct swim3 __iomem *sw = fs->swim3; struct swim3 __iomem *sw = fs->swim3;
lock_kernel(); mutex_lock(&swim3_mutex);
if (fs->ref_count > 0 && --fs->ref_count == 0) { if (fs->ref_count > 0 && --fs->ref_count == 0) {
swim3_action(fs, MOTOR_OFF); swim3_action(fs, MOTOR_OFF);
out_8(&sw->control_bic, 0xff); out_8(&sw->control_bic, 0xff);
swim3_select(fs, RELAX); swim3_select(fs, RELAX);
} }
unlock_kernel(); mutex_unlock(&swim3_mutex);
return 0; return 0;
} }

15
drivers/block/ub.c
View File

@ -28,7 +28,7 @@
#include <linux/timer.h> #include <linux/timer.h>
#include <linux/scatterlist.h> #include <linux/scatterlist.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <scsi/scsi.h> #include <scsi/scsi.h>
#define DRV_NAME "ub" #define DRV_NAME "ub"
@ -248,6 +248,7 @@ struct ub_completion {
spinlock_t lock; spinlock_t lock;
}; };
static DEFINE_MUTEX(ub_mutex);
static inline void ub_init_completion(struct ub_completion *x) static inline void ub_init_completion(struct ub_completion *x)
{ {
x->done = 0; x->done = 0;
@ -1715,9 +1716,9 @@ static int ub_bd_unlocked_open(struct block_device *bdev, fmode_t mode)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&ub_mutex);
ret = ub_bd_open(bdev, mode); ret = ub_bd_open(bdev, mode);
unlock_kernel(); mutex_unlock(&ub_mutex);
return ret; return ret;
} }
@ -1730,9 +1731,9 @@ static int ub_bd_release(struct gendisk *disk, fmode_t mode)
struct ub_lun *lun = disk->private_data; struct ub_lun *lun = disk->private_data;
struct ub_dev *sc = lun->udev; struct ub_dev *sc = lun->udev;
lock_kernel(); mutex_lock(&ub_mutex);
ub_put(sc); ub_put(sc);
unlock_kernel(); mutex_unlock(&ub_mutex);
return 0; return 0;
} }
@ -1747,9 +1748,9 @@ static int ub_bd_ioctl(struct block_device *bdev, fmode_t mode,
void __user *usermem = (void __user *) arg; void __user *usermem = (void __user *) arg;
int ret; int ret;
lock_kernel(); mutex_lock(&ub_mutex);
ret = scsi_cmd_ioctl(disk->queue, disk, mode, cmd, usermem); ret = scsi_cmd_ioctl(disk->queue, disk, mode, cmd, usermem);
unlock_kernel(); mutex_unlock(&ub_mutex);
return ret; return ret;
} }

11
drivers/block/viodasd.c
View File

@ -41,7 +41,7 @@
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/string.h> #include <linux/string.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/dma-mapping.h> #include <linux/dma-mapping.h>
#include <linux/completion.h> #include <linux/completion.h>
#include <linux/device.h> #include <linux/device.h>
@ -73,6 +73,7 @@ enum {
MAX_DISK_NAME = FIELD_SIZEOF(struct gendisk, disk_name) MAX_DISK_NAME = FIELD_SIZEOF(struct gendisk, disk_name)
}; };
static DEFINE_MUTEX(viodasd_mutex);
static DEFINE_SPINLOCK(viodasd_spinlock); static DEFINE_SPINLOCK(viodasd_spinlock);
#define VIOMAXREQ 16 #define VIOMAXREQ 16
@ -180,9 +181,9 @@ static int viodasd_unlocked_open(struct block_device *bdev, fmode_t mode)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&viodasd_mutex);
ret = viodasd_open(bdev, mode); ret = viodasd_open(bdev, mode);
unlock_kernel(); mutex_unlock(&viodasd_mutex);
return ret; return ret;
} }
@ -196,7 +197,7 @@ static int viodasd_release(struct gendisk *disk, fmode_t mode)
struct viodasd_device *d = disk->private_data; struct viodasd_device *d = disk->private_data;
HvLpEvent_Rc hvrc; HvLpEvent_Rc hvrc;
lock_kernel(); mutex_lock(&viodasd_mutex);
/* Send the event to OS/400. We DON'T expect a response */ /* Send the event to OS/400. We DON'T expect a response */
hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp, hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp,
HvLpEvent_Type_VirtualIo, HvLpEvent_Type_VirtualIo,
@ -210,7 +211,7 @@ static int viodasd_release(struct gendisk *disk, fmode_t mode)
if (hvrc != 0) if (hvrc != 0)
pr_warning("HV close call failed %d\n", (int)hvrc); pr_warning("HV close call failed %d\n", (int)hvrc);
unlock_kernel(); mutex_unlock(&viodasd_mutex);
return 0; return 0;
} }

7
drivers/block/xd.c
View File

@ -46,7 +46,7 @@
#include <linux/init.h> #include <linux/init.h>
#include <linux/wait.h> #include <linux/wait.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/blkpg.h> #include <linux/blkpg.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/io.h> #include <linux/io.h>
@ -58,6 +58,7 @@
#include "xd.h" #include "xd.h"
static DEFINE_MUTEX(xd_mutex);
static void __init do_xd_setup (int *integers); static void __init do_xd_setup (int *integers);
#ifdef MODULE #ifdef MODULE
static int xd[5] = { -1,-1,-1,-1, }; static int xd[5] = { -1,-1,-1,-1, };
@ -381,9 +382,9 @@ static int xd_ioctl(struct block_device *bdev, fmode_t mode,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&xd_mutex);
ret = xd_locked_ioctl(bdev, mode, cmd, param); ret = xd_locked_ioctl(bdev, mode, cmd, param);
unlock_kernel(); mutex_unlock(&xd_mutex);
return ret; return ret;
} }

11
drivers/block/xen-blkfront.c
View File

@ -41,7 +41,7 @@
#include <linux/cdrom.h> #include <linux/cdrom.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/scatterlist.h> #include <linux/scatterlist.h>
#include <xen/xen.h> #include <xen/xen.h>
@ -69,6 +69,7 @@ struct blk_shadow {
unsigned long frame[BLKIF_MAX_SEGMENTS_PER_REQUEST]; unsigned long frame[BLKIF_MAX_SEGMENTS_PER_REQUEST];
}; };
static DEFINE_MUTEX(blkfront_mutex);
static const struct block_device_operations xlvbd_block_fops; static const struct block_device_operations xlvbd_block_fops;
#define BLK_RING_SIZE __RING_SIZE((struct blkif_sring *)0, PAGE_SIZE) #define BLK_RING_SIZE __RING_SIZE((struct blkif_sring *)0, PAGE_SIZE)
@ -1201,7 +1202,7 @@ static int blkif_open(struct block_device *bdev, fmode_t mode)
struct blkfront_info *info; struct blkfront_info *info;
int err = 0; int err = 0;
lock_kernel(); mutex_lock(&blkfront_mutex);
info = disk->private_data; info = disk->private_data;
if (!info) { if (!info) {
@ -1219,7 +1220,7 @@ static int blkif_open(struct block_device *bdev, fmode_t mode)
mutex_unlock(&info->mutex); mutex_unlock(&info->mutex);
out: out:
unlock_kernel(); mutex_unlock(&blkfront_mutex);
return err; return err;
} }
@ -1229,7 +1230,7 @@ static int blkif_release(struct gendisk *disk, fmode_t mode)
struct block_device *bdev; struct block_device *bdev;
struct xenbus_device *xbdev; struct xenbus_device *xbdev;
lock_kernel(); mutex_lock(&blkfront_mutex);
bdev = bdget_disk(disk, 0); bdev = bdget_disk(disk, 0);
bdput(bdev); bdput(bdev);
@ -1263,7 +1264,7 @@ static int blkif_release(struct gendisk *disk, fmode_t mode)
} }
out: out:
unlock_kernel(); mutex_unlock(&blkfront_mutex);
return 0; return 0;
} }

11
drivers/block/xsysace.c
View File

@ -89,7 +89,7 @@
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/ata.h> #include <linux/ata.h>
#include <linux/hdreg.h> #include <linux/hdreg.h>
#include <linux/platform_device.h> #include <linux/platform_device.h>
@ -214,6 +214,7 @@ struct ace_device {
u16 cf_id[ATA_ID_WORDS]; u16 cf_id[ATA_ID_WORDS];
}; };
static DEFINE_MUTEX(xsysace_mutex);
static int ace_major; static int ace_major;
/* --------------------------------------------------------------------- /* ---------------------------------------------------------------------
@ -903,13 +904,13 @@ static int ace_open(struct block_device *bdev, fmode_t mode)
dev_dbg(ace->dev, "ace_open() users=%i\n", ace->users + 1); dev_dbg(ace->dev, "ace_open() users=%i\n", ace->users + 1);
lock_kernel(); mutex_lock(&xsysace_mutex);
spin_lock_irqsave(&ace->lock, flags); spin_lock_irqsave(&ace->lock, flags);
ace->users++; ace->users++;
spin_unlock_irqrestore(&ace->lock, flags); spin_unlock_irqrestore(&ace->lock, flags);
check_disk_change(bdev); check_disk_change(bdev);
unlock_kernel(); mutex_unlock(&xsysace_mutex);
return 0; return 0;
} }
@ -922,7 +923,7 @@ static int ace_release(struct gendisk *disk, fmode_t mode)
dev_dbg(ace->dev, "ace_release() users=%i\n", ace->users - 1); dev_dbg(ace->dev, "ace_release() users=%i\n", ace->users - 1);
lock_kernel(); mutex_lock(&xsysace_mutex);
spin_lock_irqsave(&ace->lock, flags); spin_lock_irqsave(&ace->lock, flags);
ace->users--; ace->users--;
if (ace->users == 0) { if (ace->users == 0) {
@ -930,7 +931,7 @@ static int ace_release(struct gendisk *disk, fmode_t mode)
ace_out(ace, ACE_CTRL, val & ~ACE_CTRL_LOCKREQ); ace_out(ace, ACE_CTRL, val & ~ACE_CTRL_LOCKREQ);
} }
spin_unlock_irqrestore(&ace->lock, flags); spin_unlock_irqrestore(&ace->lock, flags);
unlock_kernel(); mutex_unlock(&xsysace_mutex);
return 0; return 0;
} }

15
drivers/block/z2ram.c
View File

@ -33,7 +33,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/bitops.h> #include <linux/bitops.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <asm/setup.h> #include <asm/setup.h>
@ -57,6 +57,7 @@ extern struct mem_info m68k_memory[NUM_MEMINFO];
#define Z2RAM_CHUNK1024 ( Z2RAM_CHUNKSIZE >> 10 ) #define Z2RAM_CHUNK1024 ( Z2RAM_CHUNKSIZE >> 10 )
static DEFINE_MUTEX(z2ram_mutex);
static u_long *z2ram_map = NULL; static u_long *z2ram_map = NULL;
static u_long z2ram_size = 0; static u_long z2ram_size = 0;
static int z2_count = 0; static int z2_count = 0;
@ -154,7 +155,7 @@ static int z2_open(struct block_device *bdev, fmode_t mode)
device = MINOR(bdev->bd_dev); device = MINOR(bdev->bd_dev);
lock_kernel(); mutex_lock(&z2ram_mutex);
if ( current_device != -1 && current_device != device ) if ( current_device != -1 && current_device != device )
{ {
rc = -EBUSY; rc = -EBUSY;
@ -296,25 +297,25 @@ static int z2_open(struct block_device *bdev, fmode_t mode)
set_capacity(z2ram_gendisk, z2ram_size >> 9); set_capacity(z2ram_gendisk, z2ram_size >> 9);
} }
unlock_kernel(); mutex_unlock(&z2ram_mutex);
return 0; return 0;
err_out_kfree: err_out_kfree:
kfree(z2ram_map); kfree(z2ram_map);
err_out: err_out:
unlock_kernel(); mutex_unlock(&z2ram_mutex);
return rc; return rc;
} }
static int static int
z2_release(struct gendisk *disk, fmode_t mode) z2_release(struct gendisk *disk, fmode_t mode)
{ {
lock_kernel(); mutex_lock(&z2ram_mutex);
if ( current_device == -1 ) { if ( current_device == -1 ) {
unlock_kernel(); mutex_unlock(&z2ram_mutex);
return 0; return 0;
} }
unlock_kernel(); mutex_unlock(&z2ram_mutex);
/* /*
* FIXME: unmap memory * FIXME: unmap memory
*/ */

15
drivers/cdrom/gdrom.c
View File

@ -34,7 +34,7 @@
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/device.h> #include <linux/device.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/wait.h> #include <linux/wait.h>
#include <linux/workqueue.h> #include <linux/workqueue.h>
#include <linux/platform_device.h> #include <linux/platform_device.h>
@ -81,6 +81,7 @@
#define GDROM_DEFAULT_TIMEOUT (HZ * 7) #define GDROM_DEFAULT_TIMEOUT (HZ * 7)
static DEFINE_MUTEX(gdrom_mutex);
static const struct { static const struct {
int sense_key; int sense_key;
const char * const text; const char * const text;
@ -494,17 +495,17 @@ static struct cdrom_device_ops gdrom_ops = {
static int gdrom_bdops_open(struct block_device *bdev, fmode_t mode) static int gdrom_bdops_open(struct block_device *bdev, fmode_t mode)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&gdrom_mutex);
ret = cdrom_open(gd.cd_info, bdev, mode); ret = cdrom_open(gd.cd_info, bdev, mode);
unlock_kernel(); mutex_unlock(&gdrom_mutex);
return ret; return ret;
} }
static int gdrom_bdops_release(struct gendisk *disk, fmode_t mode) static int gdrom_bdops_release(struct gendisk *disk, fmode_t mode)
{ {
lock_kernel(); mutex_lock(&gdrom_mutex);
cdrom_release(gd.cd_info, mode); cdrom_release(gd.cd_info, mode);
unlock_kernel(); mutex_unlock(&gdrom_mutex);
return 0; return 0;
} }
@ -518,9 +519,9 @@ static int gdrom_bdops_ioctl(struct block_device *bdev, fmode_t mode,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&gdrom_mutex);
ret = cdrom_ioctl(gd.cd_info, bdev, mode, cmd, arg); ret = cdrom_ioctl(gd.cd_info, bdev, mode, cmd, arg);
unlock_kernel(); mutex_unlock(&gdrom_mutex);
return ret; return ret;
} }

15
drivers/cdrom/viocd.c
View File

@ -42,7 +42,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/completion.h> #include <linux/completion.h>
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/scatterlist.h> #include <linux/scatterlist.h>
@ -61,6 +61,7 @@
*/ */
#define VIOCD_MAX_CD HVMAXARCHITECTEDVIRTUALCDROMS #define VIOCD_MAX_CD HVMAXARCHITECTEDVIRTUALCDROMS
static DEFINE_MUTEX(viocd_mutex);
static const struct vio_error_entry viocd_err_table[] = { static const struct vio_error_entry viocd_err_table[] = {
{0x0201, EINVAL, "Invalid Range"}, {0x0201, EINVAL, "Invalid Range"},
{0x0202, EINVAL, "Invalid Token"}, {0x0202, EINVAL, "Invalid Token"},
@ -156,9 +157,9 @@ static int viocd_blk_open(struct block_device *bdev, fmode_t mode)
struct disk_info *di = bdev->bd_disk->private_data; struct disk_info *di = bdev->bd_disk->private_data;
int ret; int ret;
lock_kernel(); mutex_lock(&viocd_mutex);
ret = cdrom_open(&di->viocd_info, bdev, mode); ret = cdrom_open(&di->viocd_info, bdev, mode);
unlock_kernel(); mutex_unlock(&viocd_mutex);
return ret; return ret;
} }
@ -166,9 +167,9 @@ static int viocd_blk_open(struct block_device *bdev, fmode_t mode)
static int viocd_blk_release(struct gendisk *disk, fmode_t mode) static int viocd_blk_release(struct gendisk *disk, fmode_t mode)
{ {
struct disk_info *di = disk->private_data; struct disk_info *di = disk->private_data;
lock_kernel(); mutex_lock(&viocd_mutex);
cdrom_release(&di->viocd_info, mode); cdrom_release(&di->viocd_info, mode);
unlock_kernel(); mutex_unlock(&viocd_mutex);
return 0; return 0;
} }
@ -178,9 +179,9 @@ static int viocd_blk_ioctl(struct block_device *bdev, fmode_t mode,
struct disk_info *di = bdev->bd_disk->private_data; struct disk_info *di = bdev->bd_disk->private_data;
int ret; int ret;
lock_kernel(); mutex_lock(&viocd_mutex);
ret = cdrom_ioctl(&di->viocd_info, bdev, mode, cmd, arg); ret = cdrom_ioctl(&di->viocd_info, bdev, mode, cmd, arg);
unlock_kernel(); mutex_unlock(&viocd_mutex);
return ret; return ret;
} }

11
drivers/char/apm-emulation.c
View File

@ -13,7 +13,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/poll.h> #include <linux/poll.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/miscdevice.h> #include <linux/miscdevice.h>
@ -126,6 +126,7 @@ struct apm_user {
/* /*
* Local variables * Local variables
*/ */
static DEFINE_MUTEX(apm_mutex);
static atomic_t suspend_acks_pending = ATOMIC_INIT(0); static atomic_t suspend_acks_pending = ATOMIC_INIT(0);
static atomic_t userspace_notification_inhibit = ATOMIC_INIT(0); static atomic_t userspace_notification_inhibit = ATOMIC_INIT(0);
static int apm_disabled; static int apm_disabled;
@ -274,7 +275,7 @@ apm_ioctl(struct file *filp, u_int cmd, u_long arg)
if (!as->suser || !as->writer) if (!as->suser || !as->writer)
return -EPERM; return -EPERM;
lock_kernel(); mutex_lock(&apm_mutex);
switch (cmd) { switch (cmd) {
case APM_IOC_SUSPEND: case APM_IOC_SUSPEND:
mutex_lock(&state_lock); mutex_lock(&state_lock);
@ -335,7 +336,7 @@ apm_ioctl(struct file *filp, u_int cmd, u_long arg)
mutex_unlock(&state_lock); mutex_unlock(&state_lock);
break; break;
} }
unlock_kernel(); mutex_unlock(&apm_mutex);
return err; return err;
} }
@ -370,7 +371,7 @@ static int apm_open(struct inode * inode, struct file * filp)
{ {
struct apm_user *as; struct apm_user *as;
lock_kernel(); mutex_lock(&apm_mutex);
as = kzalloc(sizeof(*as), GFP_KERNEL); as = kzalloc(sizeof(*as), GFP_KERNEL);
if (as) { if (as) {
/* /*
@ -390,7 +391,7 @@ static int apm_open(struct inode * inode, struct file * filp)
filp->private_data = as; filp->private_data = as;
} }
unlock_kernel(); mutex_unlock(&apm_mutex);
return as ? 0 : -ENOMEM; return as ? 0 : -ENOMEM;
} }

9
drivers/char/applicom.c
View File

@ -26,7 +26,7 @@
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/miscdevice.h> #include <linux/miscdevice.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/wait.h> #include <linux/wait.h>
@ -60,6 +60,7 @@
#define PCI_DEVICE_ID_APPLICOM_PCI2000PFB 0x0003 #define PCI_DEVICE_ID_APPLICOM_PCI2000PFB 0x0003
#endif #endif
static DEFINE_MUTEX(ac_mutex);
static char *applicom_pci_devnames[] = { static char *applicom_pci_devnames[] = {
"PCI board", "PCI board",
"PCI2000IBS / PCI2000CAN", "PCI2000IBS / PCI2000CAN",
@ -707,7 +708,7 @@ static long ac_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
if (IS_ERR(adgl)) if (IS_ERR(adgl))
return PTR_ERR(adgl); return PTR_ERR(adgl);
lock_kernel(); mutex_lock(&ac_mutex);
IndexCard = adgl->num_card-1; IndexCard = adgl->num_card-1;
if(cmd != 6 && ((IndexCard >= MAX_BOARD) || !apbs[IndexCard].RamIO)) { if(cmd != 6 && ((IndexCard >= MAX_BOARD) || !apbs[IndexCard].RamIO)) {
@ -717,7 +718,7 @@ static long ac_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
warncount--; warncount--;
} }
kfree(adgl); kfree(adgl);
unlock_kernel(); mutex_unlock(&ac_mutex);
return -EINVAL; return -EINVAL;
} }
@ -835,7 +836,7 @@ static long ac_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
} }
Dummy = readb(apbs[IndexCard].RamIO + VERS); Dummy = readb(apbs[IndexCard].RamIO + VERS);
kfree(adgl); kfree(adgl);
unlock_kernel(); mutex_unlock(&ac_mutex);
return 0; return 0;
} }

15
drivers/char/ds1302.c
View File

@ -20,7 +20,7 @@
#include <linux/miscdevice.h> #include <linux/miscdevice.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/bcd.h> #include <linux/bcd.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/uaccess.h> #include <linux/uaccess.h>
#include <linux/io.h> #include <linux/io.h>
@ -32,6 +32,7 @@
#define RTC_MAJOR_NR 121 /* local major, change later */ #define RTC_MAJOR_NR 121 /* local major, change later */
static DEFINE_MUTEX(rtc_mutex);
static const char ds1302_name[] = "ds1302"; static const char ds1302_name[] = "ds1302";
/* Send 8 bits. */ /* Send 8 bits. */
@ -164,9 +165,9 @@ static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
struct rtc_time rtc_tm; struct rtc_time rtc_tm;
memset(&rtc_tm, 0, sizeof (struct rtc_time)); memset(&rtc_tm, 0, sizeof (struct rtc_time));
lock_kernel(); mutex_lock(&rtc_mutex);
get_rtc_time(&rtc_tm); get_rtc_time(&rtc_tm);
unlock_kernel(); mutex_unlock(&rtc_mutex);
if (copy_to_user((struct rtc_time*)arg, &rtc_tm, sizeof(struct rtc_time))) if (copy_to_user((struct rtc_time*)arg, &rtc_tm, sizeof(struct rtc_time)))
return -EFAULT; return -EFAULT;
return 0; return 0;
@ -218,7 +219,7 @@ static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
mon = bin2bcd(mon); mon = bin2bcd(mon);
yrs = bin2bcd(yrs); yrs = bin2bcd(yrs);
lock_kernel(); mutex_lock(&rtc_mutex);
local_irq_save(flags); local_irq_save(flags);
CMOS_WRITE(yrs, RTC_YEAR); CMOS_WRITE(yrs, RTC_YEAR);
CMOS_WRITE(mon, RTC_MONTH); CMOS_WRITE(mon, RTC_MONTH);
@ -227,7 +228,7 @@ static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
CMOS_WRITE(min, RTC_MINUTES); CMOS_WRITE(min, RTC_MINUTES);
CMOS_WRITE(sec, RTC_SECONDS); CMOS_WRITE(sec, RTC_SECONDS);
local_irq_restore(flags); local_irq_restore(flags);
unlock_kernel(); mutex_unlock(&rtc_mutex);
/* Notice that at this point, the RTC is updated but /* Notice that at this point, the RTC is updated but
* the kernel is still running with the old time. * the kernel is still running with the old time.
@ -247,10 +248,10 @@ static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
if(copy_from_user(&tcs_val, (int*)arg, sizeof(int))) if(copy_from_user(&tcs_val, (int*)arg, sizeof(int)))
return -EFAULT; return -EFAULT;
lock_kernel(); mutex_lock(&rtc_mutex);
tcs_val = RTC_TCR_PATTERN | (tcs_val & 0x0F); tcs_val = RTC_TCR_PATTERN | (tcs_val & 0x0F);
ds1302_writereg(RTC_TRICKLECHARGER, tcs_val); ds1302_writereg(RTC_TRICKLECHARGER, tcs_val);
unlock_kernel(); mutex_unlock(&rtc_mutex);
return 0; return 0;
} }
default: default:

8
drivers/char/ds1620.c
View File

@ -8,7 +8,7 @@
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/capability.h> #include <linux/capability.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <mach/hardware.h> #include <mach/hardware.h>
#include <asm/mach-types.h> #include <asm/mach-types.h>
@ -34,6 +34,7 @@
#define CFG_CPU 2 #define CFG_CPU 2
#define CFG_1SHOT 1 #define CFG_1SHOT 1
static DEFINE_MUTEX(ds1620_mutex);
static const char *fan_state[] = { "off", "on", "on (hardwired)" }; static const char *fan_state[] = { "off", "on", "on (hardwired)" };
/* /*
@ -210,7 +211,6 @@ static void ds1620_read_state(struct therm *therm)
static int ds1620_open(struct inode *inode, struct file *file) static int ds1620_open(struct inode *inode, struct file *file)
{ {
cycle_kernel_lock();
return nonseekable_open(inode, file); return nonseekable_open(inode, file);
} }
@ -321,9 +321,9 @@ ds1620_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&ds1620_mutex);
ret = ds1620_ioctl(file, cmd, arg); ret = ds1620_ioctl(file, cmd, arg);
unlock_kernel(); mutex_unlock(&ds1620_mutex);
return ret; return ret;
} }

27
drivers/char/dsp56k.c
View File

@ -32,7 +32,7 @@
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/device.h> #include <linux/device.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/firmware.h> #include <linux/firmware.h>
#include <linux/platform_device.h> #include <linux/platform_device.h>
#include <linux/uaccess.h> /* For put_user and get_user */ #include <linux/uaccess.h> /* For put_user and get_user */
@ -94,6 +94,7 @@
} \ } \
} }
static DEFINE_MUTEX(dsp56k_mutex);
static struct dsp56k_device { static struct dsp56k_device {
unsigned long in_use; unsigned long in_use;
long maxio, timeout; long maxio, timeout;
@ -330,9 +331,9 @@ static long dsp56k_ioctl(struct file *file, unsigned int cmd,
if (len > DSP56K_MAX_BINARY_LENGTH) { if (len > DSP56K_MAX_BINARY_LENGTH) {
return -EINVAL; return -EINVAL;
} }
lock_kernel(); mutex_lock(&dsp56k_mutex);
r = dsp56k_upload(bin, len); r = dsp56k_upload(bin, len);
unlock_kernel(); mutex_unlock(&dsp56k_mutex);
if (r < 0) { if (r < 0) {
return r; return r;
} }
@ -342,16 +343,16 @@ static long dsp56k_ioctl(struct file *file, unsigned int cmd,
case DSP56K_SET_TX_WSIZE: case DSP56K_SET_TX_WSIZE:
if (arg > 4 || arg < 1) if (arg > 4 || arg < 1)
return -EINVAL; return -EINVAL;
lock_kernel(); mutex_lock(&dsp56k_mutex);
dsp56k.tx_wsize = (int) arg; dsp56k.tx_wsize = (int) arg;
unlock_kernel(); mutex_unlock(&dsp56k_mutex);
break; break;
case DSP56K_SET_RX_WSIZE: case DSP56K_SET_RX_WSIZE:
if (arg > 4 || arg < 1) if (arg > 4 || arg < 1)
return -EINVAL; return -EINVAL;
lock_kernel(); mutex_lock(&dsp56k_mutex);
dsp56k.rx_wsize = (int) arg; dsp56k.rx_wsize = (int) arg;
unlock_kernel(); mutex_unlock(&dsp56k_mutex);
break; break;
case DSP56K_HOST_FLAGS: case DSP56K_HOST_FLAGS:
{ {
@ -363,7 +364,7 @@ static long dsp56k_ioctl(struct file *file, unsigned int cmd,
if(get_user(out, &hf->out) < 0) if(get_user(out, &hf->out) < 0)
return -EFAULT; return -EFAULT;
lock_kernel(); mutex_lock(&dsp56k_mutex);
if ((dir & 0x1) && (out & 0x1)) if ((dir & 0x1) && (out & 0x1))
dsp56k_host_interface.icr |= DSP56K_ICR_HF0; dsp56k_host_interface.icr |= DSP56K_ICR_HF0;
else if (dir & 0x1) else if (dir & 0x1)
@ -378,16 +379,16 @@ static long dsp56k_ioctl(struct file *file, unsigned int cmd,
if (dsp56k_host_interface.icr & DSP56K_ICR_HF1) status |= 0x2; if (dsp56k_host_interface.icr & DSP56K_ICR_HF1) status |= 0x2;
if (dsp56k_host_interface.isr & DSP56K_ISR_HF2) status |= 0x4; if (dsp56k_host_interface.isr & DSP56K_ISR_HF2) status |= 0x4;
if (dsp56k_host_interface.isr & DSP56K_ISR_HF3) status |= 0x8; if (dsp56k_host_interface.isr & DSP56K_ISR_HF3) status |= 0x8;
unlock_kernel(); mutex_unlock(&dsp56k_mutex);
return put_user(status, &hf->status); return put_user(status, &hf->status);
} }
case DSP56K_HOST_CMD: case DSP56K_HOST_CMD:
if (arg > 31 || arg < 0) if (arg > 31 || arg < 0)
return -EINVAL; return -EINVAL;
lock_kernel(); mutex_lock(&dsp56k_mutex);
dsp56k_host_interface.cvr = (u_char)((arg & DSP56K_CVR_HV_MASK) | dsp56k_host_interface.cvr = (u_char)((arg & DSP56K_CVR_HV_MASK) |
DSP56K_CVR_HC); DSP56K_CVR_HC);
unlock_kernel(); mutex_unlock(&dsp56k_mutex);
break; break;
default: default:
return -EINVAL; return -EINVAL;
@ -427,7 +428,7 @@ static int dsp56k_open(struct inode *inode, struct file *file)
int dev = iminor(inode) & 0x0f; int dev = iminor(inode) & 0x0f;
int ret = 0; int ret = 0;
lock_kernel(); mutex_lock(&dsp56k_mutex);
switch(dev) switch(dev)
{ {
case DSP56K_DEV_56001: case DSP56K_DEV_56001:
@ -454,7 +455,7 @@ static int dsp56k_open(struct inode *inode, struct file *file)
ret = -ENODEV; ret = -ENODEV;
} }
out: out:
unlock_kernel(); mutex_unlock(&dsp56k_mutex);
return ret; return ret;
} }

8
drivers/char/dtlk.c
View File

@ -57,7 +57,7 @@
#include <linux/ioport.h> /* for request_region */ #include <linux/ioport.h> /* for request_region */
#include <linux/delay.h> /* for loops_per_jiffy */ #include <linux/delay.h> /* for loops_per_jiffy */
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/smp_lock.h> /* cycle_kernel_lock() */ #include <linux/mutex.h>
#include <asm/io.h> /* for inb_p, outb_p, inb, outb, etc. */ #include <asm/io.h> /* for inb_p, outb_p, inb, outb, etc. */
#include <asm/uaccess.h> /* for get_user, etc. */ #include <asm/uaccess.h> /* for get_user, etc. */
#include <linux/wait.h> /* for wait_queue */ #include <linux/wait.h> /* for wait_queue */
@ -73,6 +73,7 @@
#define TRACE_RET ((void) 0) #define TRACE_RET ((void) 0)
#endif /* TRACING */ #endif /* TRACING */
static DEFINE_MUTEX(dtlk_mutex);
static void dtlk_timer_tick(unsigned long data); static void dtlk_timer_tick(unsigned long data);
static int dtlk_major; static int dtlk_major;
@ -275,9 +276,9 @@ static long dtlk_ioctl(struct file *file,
switch (cmd) { switch (cmd) {
case DTLK_INTERROGATE: case DTLK_INTERROGATE:
lock_kernel(); mutex_lock(&dtlk_mutex);
sp = dtlk_interrogate(); sp = dtlk_interrogate();
unlock_kernel(); mutex_unlock(&dtlk_mutex);
if (copy_to_user(argp, sp, sizeof(struct dtlk_settings))) if (copy_to_user(argp, sp, sizeof(struct dtlk_settings)))
return -EINVAL; return -EINVAL;
return 0; return 0;
@ -296,7 +297,6 @@ static int dtlk_open(struct inode *inode, struct file *file)
{ {
TRACE_TEXT("(dtlk_open"); TRACE_TEXT("(dtlk_open");
cycle_kernel_lock();
nonseekable_open(inode, file); nonseekable_open(inode, file);
switch (iminor(inode)) { switch (iminor(inode)) {
case DTLK_MINOR: case DTLK_MINOR:

7
drivers/char/generic_nvram.c
View File

@ -19,7 +19,7 @@
#include <linux/miscdevice.h> #include <linux/miscdevice.h>
#include <linux/fcntl.h> #include <linux/fcntl.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
#include <asm/nvram.h> #include <asm/nvram.h>
#ifdef CONFIG_PPC_PMAC #ifdef CONFIG_PPC_PMAC
@ -28,6 +28,7 @@
#define NVRAM_SIZE 8192 #define NVRAM_SIZE 8192
static DEFINE_MUTEX(nvram_mutex);
static ssize_t nvram_len; static ssize_t nvram_len;
static loff_t nvram_llseek(struct file *file, loff_t offset, int origin) static loff_t nvram_llseek(struct file *file, loff_t offset, int origin)
@ -120,9 +121,9 @@ static long nvram_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned l
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&nvram_mutex);
ret = nvram_ioctl(file, cmd, arg); ret = nvram_ioctl(file, cmd, arg);
unlock_kernel(); mutex_unlock(&nvram_mutex);
return ret; return ret;
} }

13
drivers/char/genrtc.c
View File

@ -52,7 +52,7 @@
#include <linux/init.h> #include <linux/init.h>
#include <linux/poll.h> #include <linux/poll.h>
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/workqueue.h> #include <linux/workqueue.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
@ -66,6 +66,7 @@
* ioctls. * ioctls.
*/ */
static DEFINE_MUTEX(gen_rtc_mutex);
static DECLARE_WAIT_QUEUE_HEAD(gen_rtc_wait); static DECLARE_WAIT_QUEUE_HEAD(gen_rtc_wait);
/* /*
@ -337,9 +338,9 @@ static long gen_rtc_unlocked_ioctl(struct file *file, unsigned int cmd,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&gen_rtc_mutex);
ret = gen_rtc_ioctl(file, cmd, arg); ret = gen_rtc_ioctl(file, cmd, arg);
unlock_kernel(); mutex_unlock(&gen_rtc_mutex);
return ret; return ret;
} }
@ -352,16 +353,16 @@ static long gen_rtc_unlocked_ioctl(struct file *file, unsigned int cmd,
static int gen_rtc_open(struct inode *inode, struct file *file) static int gen_rtc_open(struct inode *inode, struct file *file)
{ {
lock_kernel(); mutex_lock(&gen_rtc_mutex);
if (gen_rtc_status & RTC_IS_OPEN) { if (gen_rtc_status & RTC_IS_OPEN) {
unlock_kernel(); mutex_unlock(&gen_rtc_mutex);
return -EBUSY; return -EBUSY;
} }
gen_rtc_status |= RTC_IS_OPEN; gen_rtc_status |= RTC_IS_OPEN;
gen_rtc_irq_data = 0; gen_rtc_irq_data = 0;
irq_active = 0; irq_active = 0;
unlock_kernel(); mutex_unlock(&gen_rtc_mutex);
return 0; return 0;
} }

7
drivers/char/i8k.c
View File

@ -23,7 +23,7 @@
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/dmi.h> #include <linux/dmi.h>
#include <linux/capability.h> #include <linux/capability.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
#include <asm/io.h> #include <asm/io.h>
@ -56,6 +56,7 @@
#define I8K_TEMPERATURE_BUG 1 #define I8K_TEMPERATURE_BUG 1
static DEFINE_MUTEX(i8k_mutex);
static char bios_version[4]; static char bios_version[4];
MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)"); MODULE_AUTHOR("Massimo Dal Zotto (dz@debian.org)");
@ -399,9 +400,9 @@ static long i8k_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
{ {
long ret; long ret;
lock_kernel(); mutex_lock(&i8k_mutex);
ret = i8k_ioctl_unlocked(fp, cmd, arg); ret = i8k_ioctl_unlocked(fp, cmd, arg);
unlock_kernel(); mutex_unlock(&i8k_mutex);
return ret; return ret;
} }

8
drivers/char/ip2/ip2main.c
View File

@ -98,7 +98,7 @@
#include <linux/major.h> #include <linux/major.h>
#include <linux/wait.h> #include <linux/wait.h>
#include <linux/device.h> #include <linux/device.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/firmware.h> #include <linux/firmware.h>
#include <linux/platform_device.h> #include <linux/platform_device.h>
@ -138,6 +138,7 @@
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
static DEFINE_MUTEX(ip2_mutex);
static const struct file_operations ip2mem_proc_fops; static const struct file_operations ip2mem_proc_fops;
static const struct file_operations ip2_proc_fops; static const struct file_operations ip2_proc_fops;
@ -2897,7 +2898,7 @@ ip2_ipl_ioctl (struct file *pFile, UINT cmd, ULONG arg )
printk (KERN_DEBUG "IP2IPL: ioctl cmd %d, arg %ld\n", cmd, arg ); printk (KERN_DEBUG "IP2IPL: ioctl cmd %d, arg %ld\n", cmd, arg );
#endif #endif
lock_kernel(); mutex_lock(&ip2_mutex);
switch ( iplminor ) { switch ( iplminor ) {
case 0: // IPL device case 0: // IPL device
@ -2961,7 +2962,7 @@ ip2_ipl_ioctl (struct file *pFile, UINT cmd, ULONG arg )
rc = -ENODEV; rc = -ENODEV;
break; break;
} }
unlock_kernel(); mutex_unlock(&ip2_mutex);
return rc; return rc;
} }
@ -2982,7 +2983,6 @@ ip2_ipl_open( struct inode *pInode, struct file *pFile )
#ifdef IP2DEBUG_IPL #ifdef IP2DEBUG_IPL
printk (KERN_DEBUG "IP2IPL: open\n" ); printk (KERN_DEBUG "IP2IPL: open\n" );
#endif #endif
cycle_kernel_lock();
return 0; return 0;
} }

14
drivers/char/ipmi/ipmi_devintf.c
View File

@ -44,7 +44,6 @@
#include <linux/init.h> #include <linux/init.h>
#include <linux/device.h> #include <linux/device.h>
#include <linux/compat.h> #include <linux/compat.h>
#include <linux/smp_lock.h>
struct ipmi_file_private struct ipmi_file_private
{ {
@ -59,6 +58,7 @@ struct ipmi_file_private
unsigned int default_retry_time_ms; unsigned int default_retry_time_ms;
}; };
static DEFINE_MUTEX(ipmi_mutex);
static void file_receive_handler(struct ipmi_recv_msg *msg, static void file_receive_handler(struct ipmi_recv_msg *msg,
void *handler_data) void *handler_data)
{ {
@ -102,9 +102,9 @@ static int ipmi_fasync(int fd, struct file *file, int on)
struct ipmi_file_private *priv = file->private_data; struct ipmi_file_private *priv = file->private_data;
int result; int result;
lock_kernel(); /* could race against open() otherwise */ mutex_lock(&ipmi_mutex); /* could race against open() otherwise */
result = fasync_helper(fd, file, on, &priv->fasync_queue); result = fasync_helper(fd, file, on, &priv->fasync_queue);
unlock_kernel(); mutex_unlock(&ipmi_mutex);
return (result); return (result);
} }
@ -125,7 +125,7 @@ static int ipmi_open(struct inode *inode, struct file *file)
if (!priv) if (!priv)
return -ENOMEM; return -ENOMEM;
lock_kernel(); mutex_lock(&ipmi_mutex);
priv->file = file; priv->file = file;
rv = ipmi_create_user(if_num, rv = ipmi_create_user(if_num,
@ -150,7 +150,7 @@ static int ipmi_open(struct inode *inode, struct file *file)
priv->default_retry_time_ms = 0; priv->default_retry_time_ms = 0;
out: out:
unlock_kernel(); mutex_unlock(&ipmi_mutex);
return rv; return rv;
} }
@ -639,9 +639,9 @@ static long ipmi_unlocked_ioctl(struct file *file,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&ipmi_mutex);
ret = ipmi_ioctl(file, cmd, data); ret = ipmi_ioctl(file, cmd, data);
unlock_kernel(); mutex_unlock(&ipmi_mutex);
return ret; return ret;
} }

8
drivers/char/ipmi/ipmi_watchdog.c
View File

@ -35,7 +35,7 @@
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/ipmi.h> #include <linux/ipmi.h>
#include <linux/ipmi_smi.h> #include <linux/ipmi_smi.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/watchdog.h> #include <linux/watchdog.h>
#include <linux/miscdevice.h> #include <linux/miscdevice.h>
#include <linux/init.h> #include <linux/init.h>
@ -149,6 +149,7 @@
#define WDIOC_GET_PRETIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 22, int) #define WDIOC_GET_PRETIMEOUT _IOW(WATCHDOG_IOCTL_BASE, 22, int)
#endif #endif
static DEFINE_MUTEX(ipmi_watchdog_mutex);
static int nowayout = WATCHDOG_NOWAYOUT; static int nowayout = WATCHDOG_NOWAYOUT;
static ipmi_user_t watchdog_user; static ipmi_user_t watchdog_user;
@ -748,9 +749,9 @@ static long ipmi_unlocked_ioctl(struct file *file,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&ipmi_watchdog_mutex);
ret = ipmi_ioctl(file, cmd, arg); ret = ipmi_ioctl(file, cmd, arg);
unlock_kernel(); mutex_unlock(&ipmi_watchdog_mutex);
return ret; return ret;
} }
@ -844,7 +845,6 @@ static int ipmi_open(struct inode *ino, struct file *filep)
if (test_and_set_bit(0, &ipmi_wdog_open)) if (test_and_set_bit(0, &ipmi_wdog_open))
return -EBUSY; return -EBUSY;
cycle_kernel_lock();
/* /*
* Don't start the timer now, let it start on the * Don't start the timer now, let it start on the

15
drivers/char/lp.c
View File

@ -126,7 +126,7 @@
#include <linux/device.h> #include <linux/device.h>
#include <linux/wait.h> #include <linux/wait.h>
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/compat.h> #include <linux/compat.h>
#include <linux/parport.h> #include <linux/parport.h>
@ -140,6 +140,7 @@
/* if you have more than 8 printers, remember to increase LP_NO */ /* if you have more than 8 printers, remember to increase LP_NO */
#define LP_NO 8 #define LP_NO 8
static DEFINE_MUTEX(lp_mutex);
static struct lp_struct lp_table[LP_NO]; static struct lp_struct lp_table[LP_NO];
static unsigned int lp_count = 0; static unsigned int lp_count = 0;
@ -493,7 +494,7 @@ static int lp_open(struct inode * inode, struct file * file)
unsigned int minor = iminor(inode); unsigned int minor = iminor(inode);
int ret = 0; int ret = 0;
lock_kernel(); mutex_lock(&lp_mutex);
if (minor >= LP_NO) { if (minor >= LP_NO) {
ret = -ENXIO; ret = -ENXIO;
goto out; goto out;
@ -554,7 +555,7 @@ static int lp_open(struct inode * inode, struct file * file)
lp_release_parport (&lp_table[minor]); lp_release_parport (&lp_table[minor]);
lp_table[minor].current_mode = IEEE1284_MODE_COMPAT; lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;
out: out:
unlock_kernel(); mutex_unlock(&lp_mutex);
return ret; return ret;
} }
@ -680,7 +681,7 @@ static long lp_ioctl(struct file *file, unsigned int cmd,
int ret; int ret;
minor = iminor(file->f_path.dentry->d_inode); minor = iminor(file->f_path.dentry->d_inode);
lock_kernel(); mutex_lock(&lp_mutex);
switch (cmd) { switch (cmd) {
case LPSETTIMEOUT: case LPSETTIMEOUT:
if (copy_from_user(&par_timeout, (void __user *)arg, if (copy_from_user(&par_timeout, (void __user *)arg,
@ -694,7 +695,7 @@ static long lp_ioctl(struct file *file, unsigned int cmd,
ret = lp_do_ioctl(minor, cmd, arg, (void __user *)arg); ret = lp_do_ioctl(minor, cmd, arg, (void __user *)arg);
break; break;
} }
unlock_kernel(); mutex_unlock(&lp_mutex);
return ret; return ret;
} }
@ -709,7 +710,7 @@ static long lp_compat_ioctl(struct file *file, unsigned int cmd,
int ret; int ret;
minor = iminor(file->f_path.dentry->d_inode); minor = iminor(file->f_path.dentry->d_inode);
lock_kernel(); mutex_lock(&lp_mutex);
switch (cmd) { switch (cmd) {
case LPSETTIMEOUT: case LPSETTIMEOUT:
tc = compat_ptr(arg); tc = compat_ptr(arg);
@ -730,7 +731,7 @@ static long lp_compat_ioctl(struct file *file, unsigned int cmd,
ret = lp_do_ioctl(minor, cmd, arg, compat_ptr(arg)); ret = lp_do_ioctl(minor, cmd, arg, compat_ptr(arg));
break; break;
} }
unlock_kernel(); mutex_unlock(&lp_mutex);
return ret; return ret;
} }

8
drivers/char/mbcs.c
View File

@ -25,7 +25,6 @@
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/uio.h> #include <linux/uio.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/smp_lock.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
@ -42,6 +41,7 @@
#else #else
#define DBG(fmt...) #define DBG(fmt...)
#endif #endif
static DEFINE_MUTEX(mbcs_mutex);
static int mbcs_major; static int mbcs_major;
static LIST_HEAD(soft_list); static LIST_HEAD(soft_list);
@ -385,19 +385,19 @@ static int mbcs_open(struct inode *ip, struct file *fp)
struct mbcs_soft *soft; struct mbcs_soft *soft;
int minor; int minor;
lock_kernel(); mutex_lock(&mbcs_mutex);
minor = iminor(ip); minor = iminor(ip);
/* Nothing protects access to this list... */ /* Nothing protects access to this list... */
list_for_each_entry(soft, &soft_list, list) { list_for_each_entry(soft, &soft_list, list) {
if (soft->nasid == minor) { if (soft->nasid == minor) {
fp->private_data = soft->cxdev; fp->private_data = soft->cxdev;
unlock_kernel(); mutex_unlock(&mbcs_mutex);
return 0; return 0;
} }
} }
unlock_kernel(); mutex_unlock(&mbcs_mutex);
return -ENODEV; return -ENODEV;
} }

7
drivers/char/mmtimer.c
View File

@ -32,7 +32,7 @@
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/time.h> #include <linux/time.h>
#include <linux/math64.h> #include <linux/math64.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
@ -59,6 +59,7 @@ extern unsigned long sn_rtc_cycles_per_second;
#define rtc_time() (*RTC_COUNTER_ADDR) #define rtc_time() (*RTC_COUNTER_ADDR)
static DEFINE_MUTEX(mmtimer_mutex);
static long mmtimer_ioctl(struct file *file, unsigned int cmd, static long mmtimer_ioctl(struct file *file, unsigned int cmd,
unsigned long arg); unsigned long arg);
static int mmtimer_mmap(struct file *file, struct vm_area_struct *vma); static int mmtimer_mmap(struct file *file, struct vm_area_struct *vma);
@ -371,7 +372,7 @@ static long mmtimer_ioctl(struct file *file, unsigned int cmd,
{ {
int ret = 0; int ret = 0;
lock_kernel(); mutex_lock(&mmtimer_mutex);
switch (cmd) { switch (cmd) {
case MMTIMER_GETOFFSET: /* offset of the counter */ case MMTIMER_GETOFFSET: /* offset of the counter */
@ -414,7 +415,7 @@ static long mmtimer_ioctl(struct file *file, unsigned int cmd,
ret = -ENOTTY; ret = -ENOTTY;
break; break;
} }
unlock_kernel(); mutex_unlock(&mmtimer_mutex);
return ret; return ret;
} }

44
drivers/char/mwave/mwavedd.c
View File

@ -56,7 +56,7 @@
#include <linux/serial.h> #include <linux/serial.h>
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/serial_8250.h> #include <linux/serial_8250.h>
#include "smapi.h" #include "smapi.h"
@ -73,6 +73,7 @@ MODULE_LICENSE("GPL");
* checks are made against other devices (ie. superio) for conflicts. * checks are made against other devices (ie. superio) for conflicts.
* We'll depend on users using the tpctl utility to do that for now * We'll depend on users using the tpctl utility to do that for now
*/ */
static DEFINE_MUTEX(mwave_mutex);
int mwave_debug = 0; int mwave_debug = 0;
int mwave_3780i_irq = 0; int mwave_3780i_irq = 0;
int mwave_3780i_io = 0; int mwave_3780i_io = 0;
@ -101,7 +102,6 @@ static int mwave_open(struct inode *inode, struct file *file)
PRINTK_2(TRACE_MWAVE, PRINTK_2(TRACE_MWAVE,
"mwavedd::mwave_open, exit return retval %x\n", retval); "mwavedd::mwave_open, exit return retval %x\n", retval);
cycle_kernel_lock();
return retval; return retval;
} }
@ -136,9 +136,9 @@ static long mwave_ioctl(struct file *file, unsigned int iocmd,
PRINTK_1(TRACE_MWAVE, PRINTK_1(TRACE_MWAVE,
"mwavedd::mwave_ioctl, IOCTL_MW_RESET" "mwavedd::mwave_ioctl, IOCTL_MW_RESET"
" calling tp3780I_ResetDSP\n"); " calling tp3780I_ResetDSP\n");
lock_kernel(); mutex_lock(&mwave_mutex);
retval = tp3780I_ResetDSP(&pDrvData->rBDData); retval = tp3780I_ResetDSP(&pDrvData->rBDData);
unlock_kernel(); mutex_unlock(&mwave_mutex);
PRINTK_2(TRACE_MWAVE, PRINTK_2(TRACE_MWAVE,
"mwavedd::mwave_ioctl, IOCTL_MW_RESET" "mwavedd::mwave_ioctl, IOCTL_MW_RESET"
" retval %x from tp3780I_ResetDSP\n", " retval %x from tp3780I_ResetDSP\n",
@ -149,9 +149,9 @@ static long mwave_ioctl(struct file *file, unsigned int iocmd,
PRINTK_1(TRACE_MWAVE, PRINTK_1(TRACE_MWAVE,
"mwavedd::mwave_ioctl, IOCTL_MW_RUN" "mwavedd::mwave_ioctl, IOCTL_MW_RUN"
" calling tp3780I_StartDSP\n"); " calling tp3780I_StartDSP\n");
lock_kernel(); mutex_lock(&mwave_mutex);
retval = tp3780I_StartDSP(&pDrvData->rBDData); retval = tp3780I_StartDSP(&pDrvData->rBDData);
unlock_kernel(); mutex_unlock(&mwave_mutex);
PRINTK_2(TRACE_MWAVE, PRINTK_2(TRACE_MWAVE,
"mwavedd::mwave_ioctl, IOCTL_MW_RUN" "mwavedd::mwave_ioctl, IOCTL_MW_RUN"
" retval %x from tp3780I_StartDSP\n", " retval %x from tp3780I_StartDSP\n",
@ -165,10 +165,10 @@ static long mwave_ioctl(struct file *file, unsigned int iocmd,
"mwavedd::mwave_ioctl," "mwavedd::mwave_ioctl,"
" IOCTL_MW_DSP_ABILITIES calling" " IOCTL_MW_DSP_ABILITIES calling"
" tp3780I_QueryAbilities\n"); " tp3780I_QueryAbilities\n");
lock_kernel(); mutex_lock(&mwave_mutex);
retval = tp3780I_QueryAbilities(&pDrvData->rBDData, retval = tp3780I_QueryAbilities(&pDrvData->rBDData,
&rAbilities); &rAbilities);
unlock_kernel(); mutex_unlock(&mwave_mutex);
PRINTK_2(TRACE_MWAVE, PRINTK_2(TRACE_MWAVE,
"mwavedd::mwave_ioctl, IOCTL_MW_DSP_ABILITIES" "mwavedd::mwave_ioctl, IOCTL_MW_DSP_ABILITIES"
" retval %x from tp3780I_QueryAbilities\n", " retval %x from tp3780I_QueryAbilities\n",
@ -199,13 +199,13 @@ static long mwave_ioctl(struct file *file, unsigned int iocmd,
"mwavedd::mwave_ioctl IOCTL_MW_READ_DATA," "mwavedd::mwave_ioctl IOCTL_MW_READ_DATA,"
" size %lx, ioarg %lx pusBuffer %p\n", " size %lx, ioarg %lx pusBuffer %p\n",
rReadData.ulDataLength, ioarg, pusBuffer); rReadData.ulDataLength, ioarg, pusBuffer);
lock_kernel(); mutex_lock(&mwave_mutex);
retval = tp3780I_ReadWriteDspDStore(&pDrvData->rBDData, retval = tp3780I_ReadWriteDspDStore(&pDrvData->rBDData,
iocmd, iocmd,
pusBuffer, pusBuffer,
rReadData.ulDataLength, rReadData.ulDataLength,
rReadData.usDspAddress); rReadData.usDspAddress);
unlock_kernel(); mutex_unlock(&mwave_mutex);
} }
break; break;
@ -223,12 +223,12 @@ static long mwave_ioctl(struct file *file, unsigned int iocmd,
" size %lx, ioarg %lx pusBuffer %p\n", " size %lx, ioarg %lx pusBuffer %p\n",
rReadData.ulDataLength / 2, ioarg, rReadData.ulDataLength / 2, ioarg,
pusBuffer); pusBuffer);
lock_kernel(); mutex_lock(&mwave_mutex);
retval = tp3780I_ReadWriteDspDStore(&pDrvData->rBDData, retval = tp3780I_ReadWriteDspDStore(&pDrvData->rBDData,
iocmd, pusBuffer, iocmd, pusBuffer,
rReadData.ulDataLength / 2, rReadData.ulDataLength / 2,
rReadData.usDspAddress); rReadData.usDspAddress);
unlock_kernel(); mutex_unlock(&mwave_mutex);
} }
break; break;
@ -246,12 +246,12 @@ static long mwave_ioctl(struct file *file, unsigned int iocmd,
" size %lx, ioarg %lx pusBuffer %p\n", " size %lx, ioarg %lx pusBuffer %p\n",
rWriteData.ulDataLength, ioarg, rWriteData.ulDataLength, ioarg,
pusBuffer); pusBuffer);
lock_kernel(); mutex_lock(&mwave_mutex);
retval = tp3780I_ReadWriteDspDStore(&pDrvData->rBDData, retval = tp3780I_ReadWriteDspDStore(&pDrvData->rBDData,
iocmd, pusBuffer, iocmd, pusBuffer,
rWriteData.ulDataLength, rWriteData.ulDataLength,
rWriteData.usDspAddress); rWriteData.usDspAddress);
unlock_kernel(); mutex_unlock(&mwave_mutex);
} }
break; break;
@ -269,12 +269,12 @@ static long mwave_ioctl(struct file *file, unsigned int iocmd,
" size %lx, ioarg %lx pusBuffer %p\n", " size %lx, ioarg %lx pusBuffer %p\n",
rWriteData.ulDataLength, ioarg, rWriteData.ulDataLength, ioarg,
pusBuffer); pusBuffer);
lock_kernel(); mutex_lock(&mwave_mutex);
retval = tp3780I_ReadWriteDspIStore(&pDrvData->rBDData, retval = tp3780I_ReadWriteDspIStore(&pDrvData->rBDData,
iocmd, pusBuffer, iocmd, pusBuffer,
rWriteData.ulDataLength, rWriteData.ulDataLength,
rWriteData.usDspAddress); rWriteData.usDspAddress);
unlock_kernel(); mutex_unlock(&mwave_mutex);
} }
break; break;
@ -295,10 +295,10 @@ static long mwave_ioctl(struct file *file, unsigned int iocmd,
ipcnum, ipcnum,
pDrvData->IPCs[ipcnum].usIntCount); pDrvData->IPCs[ipcnum].usIntCount);
lock_kernel(); mutex_lock(&mwave_mutex);
pDrvData->IPCs[ipcnum].bIsHere = FALSE; pDrvData->IPCs[ipcnum].bIsHere = FALSE;
pDrvData->IPCs[ipcnum].bIsEnabled = TRUE; pDrvData->IPCs[ipcnum].bIsEnabled = TRUE;
unlock_kernel(); mutex_unlock(&mwave_mutex);
PRINTK_2(TRACE_MWAVE, PRINTK_2(TRACE_MWAVE,
"mwavedd::mwave_ioctl IOCTL_MW_REGISTER_IPC" "mwavedd::mwave_ioctl IOCTL_MW_REGISTER_IPC"
@ -323,7 +323,7 @@ static long mwave_ioctl(struct file *file, unsigned int iocmd,
ipcnum, ipcnum,
pDrvData->IPCs[ipcnum].usIntCount); pDrvData->IPCs[ipcnum].usIntCount);
lock_kernel(); mutex_lock(&mwave_mutex);
if (pDrvData->IPCs[ipcnum].bIsEnabled == TRUE) { if (pDrvData->IPCs[ipcnum].bIsEnabled == TRUE) {
DECLARE_WAITQUEUE(wait, current); DECLARE_WAITQUEUE(wait, current);
@ -364,7 +364,7 @@ static long mwave_ioctl(struct file *file, unsigned int iocmd,
" processing\n", " processing\n",
ipcnum); ipcnum);
} }
unlock_kernel(); mutex_unlock(&mwave_mutex);
} }
break; break;
@ -383,14 +383,14 @@ static long mwave_ioctl(struct file *file, unsigned int iocmd,
ipcnum); ipcnum);
return -EINVAL; return -EINVAL;
} }
lock_kernel(); mutex_lock(&mwave_mutex);
if (pDrvData->IPCs[ipcnum].bIsEnabled == TRUE) { if (pDrvData->IPCs[ipcnum].bIsEnabled == TRUE) {
pDrvData->IPCs[ipcnum].bIsEnabled = FALSE; pDrvData->IPCs[ipcnum].bIsEnabled = FALSE;
if (pDrvData->IPCs[ipcnum].bIsHere == TRUE) { if (pDrvData->IPCs[ipcnum].bIsHere == TRUE) {
wake_up_interruptible(&pDrvData->IPCs[ipcnum].ipc_wait_queue); wake_up_interruptible(&pDrvData->IPCs[ipcnum].ipc_wait_queue);
} }
} }
unlock_kernel(); mutex_unlock(&mwave_mutex);
} }
break; break;

11
drivers/char/nvram.c
View File

@ -109,10 +109,11 @@
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/io.h> #include <linux/io.h>
#include <linux/uaccess.h> #include <linux/uaccess.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <asm/system.h> #include <asm/system.h>
static DEFINE_MUTEX(nvram_mutex);
static DEFINE_SPINLOCK(nvram_state_lock); static DEFINE_SPINLOCK(nvram_state_lock);
static int nvram_open_cnt; /* #times opened */ static int nvram_open_cnt; /* #times opened */
static int nvram_open_mode; /* special open modes */ static int nvram_open_mode; /* special open modes */
@ -308,7 +309,7 @@ static long nvram_ioctl(struct file *file, unsigned int cmd,
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
return -EACCES; return -EACCES;
lock_kernel(); mutex_lock(&nvram_mutex);
spin_lock_irq(&rtc_lock); spin_lock_irq(&rtc_lock);
for (i = 0; i < NVRAM_BYTES; ++i) for (i = 0; i < NVRAM_BYTES; ++i)
@ -316,7 +317,7 @@ static long nvram_ioctl(struct file *file, unsigned int cmd,
__nvram_set_checksum(); __nvram_set_checksum();
spin_unlock_irq(&rtc_lock); spin_unlock_irq(&rtc_lock);
unlock_kernel(); mutex_unlock(&nvram_mutex);
return 0; return 0;
case NVRAM_SETCKS: case NVRAM_SETCKS:
@ -325,11 +326,11 @@ static long nvram_ioctl(struct file *file, unsigned int cmd,
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
return -EACCES; return -EACCES;
lock_kernel(); mutex_lock(&nvram_mutex);
spin_lock_irq(&rtc_lock); spin_lock_irq(&rtc_lock);
__nvram_set_checksum(); __nvram_set_checksum();
spin_unlock_irq(&rtc_lock); spin_unlock_irq(&rtc_lock);
unlock_kernel(); mutex_unlock(&nvram_mutex);
return 0; return 0;
default: default:

12
drivers/char/nwflash.c
View File

@ -25,7 +25,6 @@
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/rwsem.h> #include <linux/rwsem.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/smp_lock.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/jiffies.h> #include <linux/jiffies.h>
@ -41,6 +40,7 @@
#define NWFLASH_VERSION "6.4" #define NWFLASH_VERSION "6.4"
static DEFINE_MUTEX(flash_mutex);
static void kick_open(void); static void kick_open(void);
static int get_flash_id(void); static int get_flash_id(void);
static int erase_block(int nBlock); static int erase_block(int nBlock);
@ -96,7 +96,7 @@ static int get_flash_id(void)
static long flash_ioctl(struct file *filep, unsigned int cmd, unsigned long arg) static long flash_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
{ {
lock_kernel(); mutex_lock(&flash_mutex);
switch (cmd) { switch (cmd) {
case CMD_WRITE_DISABLE: case CMD_WRITE_DISABLE:
gbWriteBase64Enable = 0; gbWriteBase64Enable = 0;
@ -114,10 +114,10 @@ static long flash_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
default: default:
gbWriteBase64Enable = 0; gbWriteBase64Enable = 0;
gbWriteEnable = 0; gbWriteEnable = 0;
unlock_kernel(); mutex_unlock(&flash_mutex);
return -EINVAL; return -EINVAL;
} }
unlock_kernel(); mutex_unlock(&flash_mutex);
return 0; return 0;
} }
@ -282,7 +282,7 @@ static loff_t flash_llseek(struct file *file, loff_t offset, int orig)
{ {
loff_t ret; loff_t ret;
lock_kernel(); mutex_lock(&flash_mutex);
if (flashdebug) if (flashdebug)
printk(KERN_DEBUG "flash_llseek: offset=0x%X, orig=0x%X.\n", printk(KERN_DEBUG "flash_llseek: offset=0x%X, orig=0x%X.\n",
(unsigned int) offset, orig); (unsigned int) offset, orig);
@ -317,7 +317,7 @@ static loff_t flash_llseek(struct file *file, loff_t offset, int orig)
default: default:
ret = -EINVAL; ret = -EINVAL;
} }
unlock_kernel(); mutex_unlock(&flash_mutex);
return ret; return ret;
} }

12
drivers/char/pcmcia/cm4000_cs.c
View File

@ -30,7 +30,7 @@
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/bitrev.h> #include <linux/bitrev.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/uaccess.h> #include <linux/uaccess.h>
#include <linux/io.h> #include <linux/io.h>
@ -54,6 +54,8 @@
__func__ , ## args); \ __func__ , ## args); \
} while (0) } while (0)
static DEFINE_MUTEX(cmm_mutex);
#define T_1SEC (HZ) #define T_1SEC (HZ)
#define T_10MSEC msecs_to_jiffies(10) #define T_10MSEC msecs_to_jiffies(10)
#define T_20MSEC msecs_to_jiffies(20) #define T_20MSEC msecs_to_jiffies(20)
@ -1415,7 +1417,7 @@ static long cmm_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
iminor(inode), ioctl_names[_IOC_NR(cmd)]); iminor(inode), ioctl_names[_IOC_NR(cmd)]);
#endif #endif
lock_kernel(); mutex_lock(&cmm_mutex);
rc = -ENODEV; rc = -ENODEV;
link = dev_table[iminor(inode)]; link = dev_table[iminor(inode)];
if (!pcmcia_dev_present(link)) { if (!pcmcia_dev_present(link)) {
@ -1623,7 +1625,7 @@ static long cmm_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
rc = -ENOTTY; rc = -ENOTTY;
} }
out: out:
unlock_kernel(); mutex_unlock(&cmm_mutex);
return rc; return rc;
} }
@ -1637,7 +1639,7 @@ static int cmm_open(struct inode *inode, struct file *filp)
if (minor >= CM4000_MAX_DEV) if (minor >= CM4000_MAX_DEV)
return -ENODEV; return -ENODEV;
lock_kernel(); mutex_lock(&cmm_mutex);
link = dev_table[minor]; link = dev_table[minor];
if (link == NULL || !pcmcia_dev_present(link)) { if (link == NULL || !pcmcia_dev_present(link)) {
ret = -ENODEV; ret = -ENODEV;
@ -1682,7 +1684,7 @@ static int cmm_open(struct inode *inode, struct file *filp)
DEBUGP(2, dev, "<- cmm_open\n"); DEBUGP(2, dev, "<- cmm_open\n");
ret = nonseekable_open(inode, filp); ret = nonseekable_open(inode, filp);
out: out:
unlock_kernel(); mutex_unlock(&cmm_mutex);
return ret; return ret;
} }

8
drivers/char/pcmcia/cm4040_cs.c
View File

@ -24,7 +24,7 @@
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/poll.h> #include <linux/poll.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/wait.h> #include <linux/wait.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
#include <asm/io.h> #include <asm/io.h>
@ -48,6 +48,8 @@
__func__ , ## args); \ __func__ , ## args); \
} while (0) } while (0)
static DEFINE_MUTEX(cm4040_mutex);
#define CCID_DRIVER_BULK_DEFAULT_TIMEOUT (150*HZ) #define CCID_DRIVER_BULK_DEFAULT_TIMEOUT (150*HZ)
#define CCID_DRIVER_ASYNC_POWERUP_TIMEOUT (35*HZ) #define CCID_DRIVER_ASYNC_POWERUP_TIMEOUT (35*HZ)
#define CCID_DRIVER_MINIMUM_TIMEOUT (3*HZ) #define CCID_DRIVER_MINIMUM_TIMEOUT (3*HZ)
@ -440,7 +442,7 @@ static int cm4040_open(struct inode *inode, struct file *filp)
if (minor >= CM_MAX_DEV) if (minor >= CM_MAX_DEV)
return -ENODEV; return -ENODEV;
lock_kernel(); mutex_lock(&cm4040_mutex);
link = dev_table[minor]; link = dev_table[minor];
if (link == NULL || !pcmcia_dev_present(link)) { if (link == NULL || !pcmcia_dev_present(link)) {
ret = -ENODEV; ret = -ENODEV;
@ -469,7 +471,7 @@ static int cm4040_open(struct inode *inode, struct file *filp)
DEBUGP(2, dev, "<- cm4040_open (successfully)\n"); DEBUGP(2, dev, "<- cm4040_open (successfully)\n");
ret = nonseekable_open(inode, filp); ret = nonseekable_open(inode, filp);
out: out:
unlock_kernel(); mutex_unlock(&cm4040_mutex);
return ret; return ret;
} }

8
drivers/char/ppdev.c
View File

@ -67,7 +67,7 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/major.h> #include <linux/major.h>
#include <linux/ppdev.h> #include <linux/ppdev.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/uaccess.h> #include <linux/uaccess.h>
#define PP_VERSION "ppdev: user-space parallel port driver" #define PP_VERSION "ppdev: user-space parallel port driver"
@ -97,6 +97,7 @@ struct pp_struct {
/* ROUND_UP macro from fs/select.c */ /* ROUND_UP macro from fs/select.c */
#define ROUND_UP(x,y) (((x)+(y)-1)/(y)) #define ROUND_UP(x,y) (((x)+(y)-1)/(y))
static DEFINE_MUTEX(pp_do_mutex);
static inline void pp_enable_irq (struct pp_struct *pp) static inline void pp_enable_irq (struct pp_struct *pp)
{ {
struct parport *port = pp->pdev->port; struct parport *port = pp->pdev->port;
@ -630,9 +631,9 @@ static int pp_do_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
static long pp_ioctl(struct file *file, unsigned int cmd, unsigned long arg) static long pp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{ {
long ret; long ret;
lock_kernel(); mutex_lock(&pp_do_mutex);
ret = pp_do_ioctl(file, cmd, arg); ret = pp_do_ioctl(file, cmd, arg);
unlock_kernel(); mutex_unlock(&pp_do_mutex);
return ret; return ret;
} }
@ -641,7 +642,6 @@ static int pp_open (struct inode * inode, struct file * file)
unsigned int minor = iminor(inode); unsigned int minor = iminor(inode);
struct pp_struct *pp; struct pp_struct *pp;
cycle_kernel_lock();
if (minor >= PARPORT_MAX) if (minor >= PARPORT_MAX)
return -ENXIO; return -ENXIO;

7
drivers/char/rio/rio_linux.c
View File

@ -44,7 +44,7 @@
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/miscdevice.h> #include <linux/miscdevice.h>
#include <linux/init.h> #include <linux/init.h>
@ -122,6 +122,7 @@ more than 512 ports.... */
/* These constants are derived from SCO Source */ /* These constants are derived from SCO Source */
static DEFINE_MUTEX(rio_fw_mutex);
static struct Conf static struct Conf
RIOConf = { RIOConf = {
/* locator */ "RIO Config here", /* locator */ "RIO Config here",
@ -566,9 +567,9 @@ static long rio_fw_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
func_enter(); func_enter();
/* The "dev" argument isn't used. */ /* The "dev" argument isn't used. */
lock_kernel(); mutex_lock(&rio_fw_mutex);
rc = riocontrol(p, 0, cmd, arg, capable(CAP_SYS_ADMIN)); rc = riocontrol(p, 0, cmd, arg, capable(CAP_SYS_ADMIN));
unlock_kernel(); mutex_unlock(&rio_fw_mutex);
func_exit(); func_exit();
return rc; return rc;

9
drivers/char/snsc.c
View File

@ -21,7 +21,7 @@
#include <linux/poll.h> #include <linux/poll.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <asm/sn/io.h> #include <asm/sn/io.h>
#include <asm/sn/sn_sal.h> #include <asm/sn/sn_sal.h>
#include <asm/sn/module.h> #include <asm/sn/module.h>
@ -34,6 +34,7 @@
#define SCDRV_BUFSZ 2048 #define SCDRV_BUFSZ 2048
#define SCDRV_TIMEOUT 1000 #define SCDRV_TIMEOUT 1000
static DEFINE_MUTEX(scdrv_mutex);
static irqreturn_t static irqreturn_t
scdrv_interrupt(int irq, void *subch_data) scdrv_interrupt(int irq, void *subch_data)
{ {
@ -105,7 +106,7 @@ scdrv_open(struct inode *inode, struct file *file)
file->private_data = sd; file->private_data = sd;
/* hook this subchannel up to the system controller interrupt */ /* hook this subchannel up to the system controller interrupt */
lock_kernel(); mutex_lock(&scdrv_mutex);
rv = request_irq(SGI_UART_VECTOR, scdrv_interrupt, rv = request_irq(SGI_UART_VECTOR, scdrv_interrupt,
IRQF_SHARED | IRQF_DISABLED, IRQF_SHARED | IRQF_DISABLED,
SYSCTL_BASENAME, sd); SYSCTL_BASENAME, sd);
@ -113,10 +114,10 @@ scdrv_open(struct inode *inode, struct file *file)
ia64_sn_irtr_close(sd->sd_nasid, sd->sd_subch); ia64_sn_irtr_close(sd->sd_nasid, sd->sd_subch);
kfree(sd); kfree(sd);
printk("%s: irq request failed (%d)\n", __func__, rv); printk("%s: irq request failed (%d)\n", __func__, rv);
unlock_kernel(); mutex_unlock(&scdrv_mutex);
return -EBUSY; return -EBUSY;
} }
unlock_kernel(); mutex_unlock(&scdrv_mutex);
return 0; return 0;
} }

9
drivers/char/toshiba.c
View File

@ -68,7 +68,7 @@
#include <linux/stat.h> #include <linux/stat.h>
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/toshiba.h> #include <linux/toshiba.h>
#define TOSH_MINOR_DEV 181 #define TOSH_MINOR_DEV 181
@ -78,6 +78,7 @@ MODULE_AUTHOR("Jonathan Buzzard <jonathan@buzzard.org.uk>");
MODULE_DESCRIPTION("Toshiba laptop SMM driver"); MODULE_DESCRIPTION("Toshiba laptop SMM driver");
MODULE_SUPPORTED_DEVICE("toshiba"); MODULE_SUPPORTED_DEVICE("toshiba");
static DEFINE_MUTEX(tosh_mutex);
static int tosh_fn; static int tosh_fn;
module_param_named(fn, tosh_fn, int, 0); module_param_named(fn, tosh_fn, int, 0);
MODULE_PARM_DESC(fn, "User specified Fn key detection port"); MODULE_PARM_DESC(fn, "User specified Fn key detection port");
@ -274,16 +275,16 @@ static long tosh_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
return -EINVAL; return -EINVAL;
/* do we need to emulate the fan ? */ /* do we need to emulate the fan ? */
lock_kernel(); mutex_lock(&tosh_mutex);
if (tosh_fan==1) { if (tosh_fan==1) {
if (((ax==0xf300) || (ax==0xf400)) && (bx==0x0004)) { if (((ax==0xf300) || (ax==0xf400)) && (bx==0x0004)) {
err = tosh_emulate_fan(&regs); err = tosh_emulate_fan(&regs);
unlock_kernel(); mutex_unlock(&tosh_mutex);
break; break;
} }
} }
err = tosh_smm(&regs); err = tosh_smm(&regs);
unlock_kernel(); mutex_unlock(&tosh_mutex);
break; break;
default: default:
return -EINVAL; return -EINVAL;

11
drivers/char/viotape.c
View File

@ -46,7 +46,7 @@
#include <linux/completion.h> #include <linux/completion.h>
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
@ -64,6 +64,7 @@
#define VIOTAPE_KERN_WARN KERN_WARNING "viotape: " #define VIOTAPE_KERN_WARN KERN_WARNING "viotape: "
#define VIOTAPE_KERN_INFO KERN_INFO "viotape: " #define VIOTAPE_KERN_INFO KERN_INFO "viotape: "
static DEFINE_MUTEX(proc_viotape_mutex);
static int viotape_numdev; static int viotape_numdev;
/* /*
@ -684,9 +685,9 @@ static long viotap_unlocked_ioctl(struct file *file,
{ {
long rc; long rc;
lock_kernel(); mutex_lock(&proc_viotape_mutex);
rc = viotap_ioctl(file->f_path.dentry->d_inode, file, cmd, arg); rc = viotap_ioctl(file->f_path.dentry->d_inode, file, cmd, arg);
unlock_kernel(); mutex_unlock(&proc_viotape_mutex);
return rc; return rc;
} }
@ -700,7 +701,7 @@ static int viotap_open(struct inode *inode, struct file *file)
if (op == NULL) if (op == NULL)
return -ENOMEM; return -ENOMEM;
lock_kernel(); mutex_lock(&proc_viotape_mutex);
get_dev_info(file->f_path.dentry->d_inode, &devi); get_dev_info(file->f_path.dentry->d_inode, &devi);
/* Note: We currently only support one mode! */ /* Note: We currently only support one mode! */
@ -731,7 +732,7 @@ static int viotap_open(struct inode *inode, struct file *file)
free_op: free_op:
free_op_struct(op); free_op_struct(op);
unlock_kernel(); mutex_unlock(&proc_viotape_mutex);
return ret; return ret;
} }

6
drivers/char/xilinx_hwicap/xilinx_hwicap.c
View File

@ -81,7 +81,6 @@
#include <linux/poll.h> #include <linux/poll.h>
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/smp_lock.h>
#include <linux/sysctl.h> #include <linux/sysctl.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/cdev.h> #include <linux/cdev.h>
@ -112,6 +111,7 @@
#define HWICAP_DEVICES 1 #define HWICAP_DEVICES 1
/* An array, which is set to true when the device is registered. */ /* An array, which is set to true when the device is registered. */
static DEFINE_MUTEX(hwicap_mutex);
static bool probed_devices[HWICAP_DEVICES]; static bool probed_devices[HWICAP_DEVICES];
static struct mutex icap_sem; static struct mutex icap_sem;
@ -502,7 +502,7 @@ static int hwicap_open(struct inode *inode, struct file *file)
struct hwicap_drvdata *drvdata; struct hwicap_drvdata *drvdata;
int status; int status;
lock_kernel(); mutex_lock(&hwicap_mutex);
drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev); drvdata = container_of(inode->i_cdev, struct hwicap_drvdata, cdev);
status = mutex_lock_interruptible(&drvdata->sem); status = mutex_lock_interruptible(&drvdata->sem);
@ -528,7 +528,7 @@ static int hwicap_open(struct inode *inode, struct file *file)
error: error:
mutex_unlock(&drvdata->sem); mutex_unlock(&drvdata->sem);
out: out:
unlock_kernel(); mutex_unlock(&hwicap_mutex);
return status; return status;
} }

6
drivers/hwmon/fschmd.c
View File

@ -38,7 +38,6 @@
#include <linux/i2c.h> #include <linux/i2c.h>
#include <linux/hwmon.h> #include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h> #include <linux/hwmon-sysfs.h>
#include <linux/smp_lock.h>
#include <linux/err.h> #include <linux/err.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/sysfs.h> #include <linux/sysfs.h>
@ -50,6 +49,7 @@
#include <linux/kref.h> #include <linux/kref.h>
/* Addresses to scan */ /* Addresses to scan */
static DEFINE_MUTEX(watchdog_mutex);
static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END }; static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
/* Insmod parameters */ /* Insmod parameters */
@ -858,7 +858,7 @@ static long watchdog_ioctl(struct file *filp, unsigned int cmd, unsigned long ar
int i, ret = 0; int i, ret = 0;
struct fschmd_data *data = filp->private_data; struct fschmd_data *data = filp->private_data;
lock_kernel(); mutex_lock(&watchdog_mutex);
switch (cmd) { switch (cmd) {
case WDIOC_GETSUPPORT: case WDIOC_GETSUPPORT:
ident.firmware_version = data->revision; ident.firmware_version = data->revision;
@ -915,7 +915,7 @@ static long watchdog_ioctl(struct file *filp, unsigned int cmd, unsigned long ar
default: default:
ret = -ENOTTY; ret = -ENOTTY;
} }
unlock_kernel(); mutex_unlock(&watchdog_mutex);
return ret; return ret;
} }

6
drivers/hwmon/w83793.c
View File

@ -35,7 +35,6 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/i2c.h> #include <linux/i2c.h>
#include <linux/hwmon.h> #include <linux/hwmon.h>
#include <linux/smp_lock.h>
#include <linux/hwmon-vid.h> #include <linux/hwmon-vid.h>
#include <linux/hwmon-sysfs.h> #include <linux/hwmon-sysfs.h>
#include <linux/err.h> #include <linux/err.h>
@ -52,6 +51,7 @@
#define WATCHDOG_TIMEOUT 2 /* 2 minute default timeout */ #define WATCHDOG_TIMEOUT 2 /* 2 minute default timeout */
/* Addresses to scan */ /* Addresses to scan */
static DEFINE_MUTEX(watchdog_mutex);
static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
I2C_CLIENT_END }; I2C_CLIENT_END };
@ -1333,7 +1333,7 @@ static long watchdog_ioctl(struct file *filp, unsigned int cmd,
int val, ret = 0; int val, ret = 0;
struct w83793_data *data = filp->private_data; struct w83793_data *data = filp->private_data;
lock_kernel(); mutex_lock(&watchdog_mutex);
switch (cmd) { switch (cmd) {
case WDIOC_GETSUPPORT: case WDIOC_GETSUPPORT:
if (!nowayout) if (!nowayout)
@ -1387,7 +1387,7 @@ static long watchdog_ioctl(struct file *filp, unsigned int cmd,
default: default:
ret = -ENOTTY; ret = -ENOTTY;
} }
unlock_kernel(); mutex_unlock(&watchdog_mutex);
return ret; return ret;
} }

14
drivers/ide/ide-cd.c
View File

@ -31,7 +31,6 @@
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/timer.h> #include <linux/timer.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/smp_lock.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/errno.h> #include <linux/errno.h>
@ -52,6 +51,7 @@
#include "ide-cd.h" #include "ide-cd.h"
static DEFINE_MUTEX(ide_cd_mutex);
static DEFINE_MUTEX(idecd_ref_mutex); static DEFINE_MUTEX(idecd_ref_mutex);
static void ide_cd_release(struct device *); static void ide_cd_release(struct device *);
@ -1602,7 +1602,7 @@ static int idecd_open(struct block_device *bdev, fmode_t mode)
struct cdrom_info *info; struct cdrom_info *info;
int rc = -ENXIO; int rc = -ENXIO;
lock_kernel(); mutex_lock(&ide_cd_mutex);
info = ide_cd_get(bdev->bd_disk); info = ide_cd_get(bdev->bd_disk);
if (!info) if (!info)
goto out; goto out;
@ -1611,7 +1611,7 @@ static int idecd_open(struct block_device *bdev, fmode_t mode)
if (rc < 0) if (rc < 0)
ide_cd_put(info); ide_cd_put(info);
out: out:
unlock_kernel(); mutex_unlock(&ide_cd_mutex);
return rc; return rc;
} }
@ -1619,11 +1619,11 @@ static int idecd_release(struct gendisk *disk, fmode_t mode)
{ {
struct cdrom_info *info = ide_drv_g(disk, cdrom_info); struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
lock_kernel(); mutex_lock(&ide_cd_mutex);
cdrom_release(&info->devinfo, mode); cdrom_release(&info->devinfo, mode);
ide_cd_put(info); ide_cd_put(info);
unlock_kernel(); mutex_unlock(&ide_cd_mutex);
return 0; return 0;
} }
@ -1694,9 +1694,9 @@ static int idecd_ioctl(struct block_device *bdev, fmode_t mode,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&ide_cd_mutex);
ret = idecd_locked_ioctl(bdev, mode, cmd, arg); ret = idecd_locked_ioctl(bdev, mode, cmd, arg);
unlock_kernel(); mutex_unlock(&ide_cd_mutex);
return ret; return ret;
} }

7
drivers/ide/ide-disk_ioctl.c
View File

@ -1,10 +1,11 @@
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/ide.h> #include <linux/ide.h>
#include <linux/hdreg.h> #include <linux/hdreg.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include "ide-disk.h" #include "ide-disk.h"
static DEFINE_MUTEX(ide_disk_ioctl_mutex);
static const struct ide_ioctl_devset ide_disk_ioctl_settings[] = { static const struct ide_ioctl_devset ide_disk_ioctl_settings[] = {
{ HDIO_GET_ADDRESS, HDIO_SET_ADDRESS, &ide_devset_address }, { HDIO_GET_ADDRESS, HDIO_SET_ADDRESS, &ide_devset_address },
{ HDIO_GET_MULTCOUNT, HDIO_SET_MULTCOUNT, &ide_devset_multcount }, { HDIO_GET_MULTCOUNT, HDIO_SET_MULTCOUNT, &ide_devset_multcount },
@ -19,13 +20,13 @@ int ide_disk_ioctl(ide_drive_t *drive, struct block_device *bdev, fmode_t mode,
{ {
int err; int err;
lock_kernel(); mutex_lock(&ide_disk_ioctl_mutex);
err = ide_setting_ioctl(drive, bdev, cmd, arg, ide_disk_ioctl_settings); err = ide_setting_ioctl(drive, bdev, cmd, arg, ide_disk_ioctl_settings);
if (err != -EOPNOTSUPP) if (err != -EOPNOTSUPP)
goto out; goto out;
err = generic_ide_ioctl(drive, bdev, cmd, arg); err = generic_ide_ioctl(drive, bdev, cmd, arg);
out: out:
unlock_kernel(); mutex_unlock(&ide_disk_ioctl_mutex);
return err; return err;
} }

7
drivers/ide/ide-floppy_ioctl.c
View File

@ -5,7 +5,7 @@
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/ide.h> #include <linux/ide.h>
#include <linux/cdrom.h> #include <linux/cdrom.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <asm/unaligned.h> #include <asm/unaligned.h>
@ -32,6 +32,7 @@
* On exit we set nformats to the number of records we've actually initialized. * On exit we set nformats to the number of records we've actually initialized.
*/ */
static DEFINE_MUTEX(ide_floppy_ioctl_mutex);
static int ide_floppy_get_format_capacities(ide_drive_t *drive, static int ide_floppy_get_format_capacities(ide_drive_t *drive,
struct ide_atapi_pc *pc, struct ide_atapi_pc *pc,
int __user *arg) int __user *arg)
@ -276,7 +277,7 @@ int ide_floppy_ioctl(ide_drive_t *drive, struct block_device *bdev,
void __user *argp = (void __user *)arg; void __user *argp = (void __user *)arg;
int err; int err;
lock_kernel(); mutex_lock(&ide_floppy_ioctl_mutex);
if (cmd == CDROMEJECT || cmd == CDROM_LOCKDOOR) { if (cmd == CDROMEJECT || cmd == CDROM_LOCKDOOR) {
err = ide_floppy_lockdoor(drive, &pc, arg, cmd); err = ide_floppy_lockdoor(drive, &pc, arg, cmd);
goto out; goto out;
@ -298,6 +299,6 @@ int ide_floppy_ioctl(ide_drive_t *drive, struct block_device *bdev,
err = generic_ide_ioctl(drive, bdev, cmd, arg); err = generic_ide_ioctl(drive, bdev, cmd, arg);
out: out:
unlock_kernel(); mutex_unlock(&ide_floppy_ioctl_mutex);
return err; return err;
} }

10
drivers/ide/ide-gd.c
View File

@ -1,4 +1,3 @@
#include <linux/smp_lock.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/types.h> #include <linux/types.h>
#include <linux/string.h> #include <linux/string.h>
@ -23,6 +22,7 @@
#define IDE_GD_VERSION "1.18" #define IDE_GD_VERSION "1.18"
/* module parameters */ /* module parameters */
static DEFINE_MUTEX(ide_gd_mutex);
static unsigned long debug_mask; static unsigned long debug_mask;
module_param(debug_mask, ulong, 0644); module_param(debug_mask, ulong, 0644);
@ -242,9 +242,9 @@ static int ide_gd_unlocked_open(struct block_device *bdev, fmode_t mode)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&ide_gd_mutex);
ret = ide_gd_open(bdev, mode); ret = ide_gd_open(bdev, mode);
unlock_kernel(); mutex_unlock(&ide_gd_mutex);
return ret; return ret;
} }
@ -257,7 +257,7 @@ static int ide_gd_release(struct gendisk *disk, fmode_t mode)
ide_debug_log(IDE_DBG_FUNC, "enter"); ide_debug_log(IDE_DBG_FUNC, "enter");
lock_kernel(); mutex_lock(&ide_gd_mutex);
if (idkp->openers == 1) if (idkp->openers == 1)
drive->disk_ops->flush(drive); drive->disk_ops->flush(drive);
@ -269,7 +269,7 @@ static int ide_gd_release(struct gendisk *disk, fmode_t mode)
idkp->openers--; idkp->openers--;
ide_disk_put(idkp); ide_disk_put(idkp);
unlock_kernel(); mutex_unlock(&ide_gd_mutex);
return 0; return 0;
} }

19
drivers/ide/ide-tape.c
View File

@ -32,11 +32,9 @@
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/genhd.h> #include <linux/genhd.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/smp_lock.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/ide.h> #include <linux/ide.h>
#include <linux/smp_lock.h>
#include <linux/completion.h> #include <linux/completion.h>
#include <linux/bitops.h> #include <linux/bitops.h>
#include <linux/mutex.h> #include <linux/mutex.h>
@ -220,6 +218,7 @@ typedef struct ide_tape_obj {
char write_prot; char write_prot;
} idetape_tape_t; } idetape_tape_t;
static DEFINE_MUTEX(ide_tape_mutex);
static DEFINE_MUTEX(idetape_ref_mutex); static DEFINE_MUTEX(idetape_ref_mutex);
static DEFINE_MUTEX(idetape_chrdev_mutex); static DEFINE_MUTEX(idetape_chrdev_mutex);
@ -1426,9 +1425,9 @@ static long idetape_chrdev_ioctl(struct file *file,
unsigned int cmd, unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
long ret; long ret;
lock_kernel(); mutex_lock(&ide_tape_mutex);
ret = do_idetape_chrdev_ioctl(file, cmd, arg); ret = do_idetape_chrdev_ioctl(file, cmd, arg);
unlock_kernel(); mutex_unlock(&ide_tape_mutex);
return ret; return ret;
} }
@ -1909,9 +1908,9 @@ static int idetape_open(struct block_device *bdev, fmode_t mode)
{ {
struct ide_tape_obj *tape; struct ide_tape_obj *tape;
lock_kernel(); mutex_lock(&ide_tape_mutex);
tape = ide_tape_get(bdev->bd_disk, false, 0); tape = ide_tape_get(bdev->bd_disk, false, 0);
unlock_kernel(); mutex_unlock(&ide_tape_mutex);
if (!tape) if (!tape)
return -ENXIO; return -ENXIO;
@ -1923,9 +1922,9 @@ static int idetape_release(struct gendisk *disk, fmode_t mode)
{ {
struct ide_tape_obj *tape = ide_drv_g(disk, ide_tape_obj); struct ide_tape_obj *tape = ide_drv_g(disk, ide_tape_obj);
lock_kernel(); mutex_lock(&ide_tape_mutex);
ide_tape_put(tape); ide_tape_put(tape);
unlock_kernel(); mutex_unlock(&ide_tape_mutex);
return 0; return 0;
} }
@ -1937,11 +1936,11 @@ static int idetape_ioctl(struct block_device *bdev, fmode_t mode,
ide_drive_t *drive = tape->drive; ide_drive_t *drive = tape->drive;
int err; int err;
lock_kernel(); mutex_lock(&ide_tape_mutex);
err = generic_ide_ioctl(drive, bdev, cmd, arg); err = generic_ide_ioctl(drive, bdev, cmd, arg);
if (err == -EINVAL) if (err == -EINVAL)
err = idetape_blkdev_ioctl(drive, cmd, arg); err = idetape_blkdev_ioctl(drive, cmd, arg);
unlock_kernel(); mutex_unlock(&ide_tape_mutex);
return err; return err;
} }

7
drivers/input/misc/hp_sdc_rtc.c
View File

@ -43,7 +43,7 @@
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/poll.h> #include <linux/poll.h>
#include <linux/rtc.h> #include <linux/rtc.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/semaphore.h> #include <linux/semaphore.h>
MODULE_AUTHOR("Brian S. Julin <bri@calyx.com>"); MODULE_AUTHOR("Brian S. Julin <bri@calyx.com>");
@ -52,6 +52,7 @@ MODULE_LICENSE("Dual BSD/GPL");
#define RTC_VERSION "1.10d" #define RTC_VERSION "1.10d"
static DEFINE_MUTEX(hp_sdc_rtc_mutex);
static unsigned long epoch = 2000; static unsigned long epoch = 2000;
static struct semaphore i8042tregs; static struct semaphore i8042tregs;
@ -665,9 +666,9 @@ static long hp_sdc_rtc_unlocked_ioctl(struct file *file,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&hp_sdc_rtc_mutex);
ret = hp_sdc_rtc_ioctl(file, cmd, arg); ret = hp_sdc_rtc_ioctl(file, cmd, arg);
unlock_kernel(); mutex_unlock(&hp_sdc_rtc_mutex);
return ret; return ret;
} }

10
drivers/macintosh/adb.c
View File

@ -24,7 +24,6 @@
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/smp_lock.h>
#include <linux/adb.h> #include <linux/adb.h>
#include <linux/cuda.h> #include <linux/cuda.h>
#include <linux/pmu.h> #include <linux/pmu.h>
@ -55,6 +54,7 @@ extern struct adb_driver adb_iop_driver;
extern struct adb_driver via_pmu_driver; extern struct adb_driver via_pmu_driver;
extern struct adb_driver macio_adb_driver; extern struct adb_driver macio_adb_driver;
static DEFINE_MUTEX(adb_mutex);
static struct adb_driver *adb_driver_list[] = { static struct adb_driver *adb_driver_list[] = {
#ifdef CONFIG_ADB_MACII #ifdef CONFIG_ADB_MACII
&via_macii_driver, &via_macii_driver,
@ -647,7 +647,7 @@ static int adb_open(struct inode *inode, struct file *file)
struct adbdev_state *state; struct adbdev_state *state;
int ret = 0; int ret = 0;
lock_kernel(); mutex_lock(&adb_mutex);
if (iminor(inode) > 0 || adb_controller == NULL) { if (iminor(inode) > 0 || adb_controller == NULL) {
ret = -ENXIO; ret = -ENXIO;
goto out; goto out;
@ -665,7 +665,7 @@ static int adb_open(struct inode *inode, struct file *file)
state->inuse = 1; state->inuse = 1;
out: out:
unlock_kernel(); mutex_unlock(&adb_mutex);
return ret; return ret;
} }
@ -674,7 +674,7 @@ static int adb_release(struct inode *inode, struct file *file)
struct adbdev_state *state = file->private_data; struct adbdev_state *state = file->private_data;
unsigned long flags; unsigned long flags;
lock_kernel(); mutex_lock(&adb_mutex);
if (state) { if (state) {
file->private_data = NULL; file->private_data = NULL;
spin_lock_irqsave(&state->lock, flags); spin_lock_irqsave(&state->lock, flags);
@ -687,7 +687,7 @@ static int adb_release(struct inode *inode, struct file *file)
spin_unlock_irqrestore(&state->lock, flags); spin_unlock_irqrestore(&state->lock, flags);
} }
} }
unlock_kernel(); mutex_unlock(&adb_mutex);
return 0; return 0;
} }

6
drivers/macintosh/smu.c
View File

@ -19,7 +19,6 @@
* the userland interface * the userland interface
*/ */
#include <linux/smp_lock.h>
#include <linux/types.h> #include <linux/types.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/device.h> #include <linux/device.h>
@ -97,6 +96,7 @@ struct smu_device {
* I don't think there will ever be more than one SMU, so * I don't think there will ever be more than one SMU, so
* for now, just hard code that * for now, just hard code that
*/ */
static DEFINE_MUTEX(smu_mutex);
static struct smu_device *smu; static struct smu_device *smu;
static DEFINE_MUTEX(smu_part_access); static DEFINE_MUTEX(smu_part_access);
static int smu_irq_inited; static int smu_irq_inited;
@ -1095,12 +1095,12 @@ static int smu_open(struct inode *inode, struct file *file)
pp->mode = smu_file_commands; pp->mode = smu_file_commands;
init_waitqueue_head(&pp->wait); init_waitqueue_head(&pp->wait);
lock_kernel(); mutex_lock(&smu_mutex);
spin_lock_irqsave(&smu_clist_lock, flags); spin_lock_irqsave(&smu_clist_lock, flags);
list_add(&pp->list, &smu_clist); list_add(&pp->list, &smu_clist);
spin_unlock_irqrestore(&smu_clist_lock, flags); spin_unlock_irqrestore(&smu_clist_lock, flags);
file->private_data = pp; file->private_data = pp;
unlock_kernel(); mutex_unlock(&smu_mutex);
return 0; return 0;
} }

11
drivers/macintosh/via-pmu.c
View File

@ -18,7 +18,7 @@
* *
*/ */
#include <stdarg.h> #include <stdarg.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/types.h> #include <linux/types.h>
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/kernel.h> #include <linux/kernel.h>
@ -73,6 +73,7 @@
/* How many iterations between battery polls */ /* How many iterations between battery polls */
#define BATTERY_POLLING_COUNT 2 #define BATTERY_POLLING_COUNT 2
static DEFINE_MUTEX(pmu_info_proc_mutex);
static volatile unsigned char __iomem *via; static volatile unsigned char __iomem *via;
/* VIA registers - spaced 0x200 bytes apart */ /* VIA registers - spaced 0x200 bytes apart */
@ -2078,7 +2079,7 @@ pmu_open(struct inode *inode, struct file *file)
pp->rb_get = pp->rb_put = 0; pp->rb_get = pp->rb_put = 0;
spin_lock_init(&pp->lock); spin_lock_init(&pp->lock);
init_waitqueue_head(&pp->wait); init_waitqueue_head(&pp->wait);
lock_kernel(); mutex_lock(&pmu_info_proc_mutex);
spin_lock_irqsave(&all_pvt_lock, flags); spin_lock_irqsave(&all_pvt_lock, flags);
#if defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT) #if defined(CONFIG_INPUT_ADBHID) && defined(CONFIG_PMAC_BACKLIGHT)
pp->backlight_locker = 0; pp->backlight_locker = 0;
@ -2086,7 +2087,7 @@ pmu_open(struct inode *inode, struct file *file)
list_add(&pp->list, &all_pmu_pvt); list_add(&pp->list, &all_pmu_pvt);
spin_unlock_irqrestore(&all_pvt_lock, flags); spin_unlock_irqrestore(&all_pvt_lock, flags);
file->private_data = pp; file->private_data = pp;
unlock_kernel(); mutex_unlock(&pmu_info_proc_mutex);
return 0; return 0;
} }
@ -2343,9 +2344,9 @@ static long pmu_unlocked_ioctl(struct file *filp,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&pmu_info_proc_mutex);
ret = pmu_ioctl(filp, cmd, arg); ret = pmu_ioctl(filp, cmd, arg);
unlock_kernel(); mutex_unlock(&pmu_info_proc_mutex);
return ret; return ret;
} }

10
drivers/md/dm.c
View File

@ -15,7 +15,6 @@
#include <linux/blkpg.h> #include <linux/blkpg.h>
#include <linux/bio.h> #include <linux/bio.h>
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#include <linux/smp_lock.h>
#include <linux/mempool.h> #include <linux/mempool.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/idr.h> #include <linux/idr.h>
@ -33,6 +32,7 @@
#define DM_COOKIE_ENV_VAR_NAME "DM_COOKIE" #define DM_COOKIE_ENV_VAR_NAME "DM_COOKIE"
#define DM_COOKIE_LENGTH 24 #define DM_COOKIE_LENGTH 24
static DEFINE_MUTEX(dm_mutex);
static const char *_name = DM_NAME; static const char *_name = DM_NAME;
static unsigned int major = 0; static unsigned int major = 0;
@ -344,7 +344,7 @@ static int dm_blk_open(struct block_device *bdev, fmode_t mode)
{ {
struct mapped_device *md; struct mapped_device *md;
lock_kernel(); mutex_lock(&dm_mutex);
spin_lock(&_minor_lock); spin_lock(&_minor_lock);
md = bdev->bd_disk->private_data; md = bdev->bd_disk->private_data;
@ -362,7 +362,7 @@ static int dm_blk_open(struct block_device *bdev, fmode_t mode)
out: out:
spin_unlock(&_minor_lock); spin_unlock(&_minor_lock);
unlock_kernel(); mutex_unlock(&dm_mutex);
return md ? 0 : -ENXIO; return md ? 0 : -ENXIO;
} }
@ -371,10 +371,10 @@ static int dm_blk_close(struct gendisk *disk, fmode_t mode)
{ {
struct mapped_device *md = disk->private_data; struct mapped_device *md = disk->private_data;
lock_kernel(); mutex_lock(&dm_mutex);
atomic_dec(&md->open_count); atomic_dec(&md->open_count);
dm_put(md); dm_put(md);
unlock_kernel(); mutex_unlock(&dm_mutex);
return 0; return 0;
} }

13
drivers/md/md.c
View File

@ -36,7 +36,7 @@
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/sysctl.h> #include <linux/sysctl.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/buffer_head.h> /* for invalidate_bdev */ #include <linux/buffer_head.h> /* for invalidate_bdev */
#include <linux/poll.h> #include <linux/poll.h>
#include <linux/ctype.h> #include <linux/ctype.h>
@ -57,6 +57,7 @@
#define DEBUG 0 #define DEBUG 0
#define dprintk(x...) ((void)(DEBUG && printk(x))) #define dprintk(x...) ((void)(DEBUG && printk(x)))
static DEFINE_MUTEX(md_mutex);
#ifndef MODULE #ifndef MODULE
static void autostart_arrays(int part); static void autostart_arrays(int part);
@ -5951,7 +5952,7 @@ static int md_open(struct block_device *bdev, fmode_t mode)
mddev_t *mddev = mddev_find(bdev->bd_dev); mddev_t *mddev = mddev_find(bdev->bd_dev);
int err; int err;
lock_kernel(); mutex_lock(&md_mutex);
if (mddev->gendisk != bdev->bd_disk) { if (mddev->gendisk != bdev->bd_disk) {
/* we are racing with mddev_put which is discarding this /* we are racing with mddev_put which is discarding this
* bd_disk. * bd_disk.
@ -5960,7 +5961,7 @@ static int md_open(struct block_device *bdev, fmode_t mode)
/* Wait until bdev->bd_disk is definitely gone */ /* Wait until bdev->bd_disk is definitely gone */
flush_scheduled_work(); flush_scheduled_work();
/* Then retry the open from the top */ /* Then retry the open from the top */
unlock_kernel(); mutex_unlock(&md_mutex);
return -ERESTARTSYS; return -ERESTARTSYS;
} }
BUG_ON(mddev != bdev->bd_disk->private_data); BUG_ON(mddev != bdev->bd_disk->private_data);
@ -5974,7 +5975,7 @@ static int md_open(struct block_device *bdev, fmode_t mode)
check_disk_size_change(mddev->gendisk, bdev); check_disk_size_change(mddev->gendisk, bdev);
out: out:
unlock_kernel(); mutex_unlock(&md_mutex);
return err; return err;
} }
@ -5983,10 +5984,10 @@ static int md_release(struct gendisk *disk, fmode_t mode)
mddev_t *mddev = disk->private_data; mddev_t *mddev = disk->private_data;
BUG_ON(!mddev); BUG_ON(!mddev);
lock_kernel(); mutex_lock(&md_mutex);
atomic_dec(&mddev->openers); atomic_dec(&mddev->openers);
mddev_put(mddev); mddev_put(mddev);
unlock_kernel(); mutex_unlock(&md_mutex);
return 0; return 0;
} }

11
drivers/memstick/core/mspro_block.c
View File

@ -18,11 +18,12 @@
#include <linux/kthread.h> #include <linux/kthread.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/memstick.h> #include <linux/memstick.h>
#define DRIVER_NAME "mspro_block" #define DRIVER_NAME "mspro_block"
static DEFINE_MUTEX(mspro_block_mutex);
static int major; static int major;
module_param(major, int, 0644); module_param(major, int, 0644);
@ -180,7 +181,7 @@ static int mspro_block_bd_open(struct block_device *bdev, fmode_t mode)
struct mspro_block_data *msb = disk->private_data; struct mspro_block_data *msb = disk->private_data;
int rc = -ENXIO; int rc = -ENXIO;
lock_kernel(); mutex_lock(&mspro_block_mutex);
mutex_lock(&mspro_block_disk_lock); mutex_lock(&mspro_block_disk_lock);
if (msb && msb->card) { if (msb && msb->card) {
@ -192,7 +193,7 @@ static int mspro_block_bd_open(struct block_device *bdev, fmode_t mode)
} }
mutex_unlock(&mspro_block_disk_lock); mutex_unlock(&mspro_block_disk_lock);
unlock_kernel(); mutex_unlock(&mspro_block_mutex);
return rc; return rc;
} }
@ -225,9 +226,9 @@ static int mspro_block_disk_release(struct gendisk *disk)
static int mspro_block_bd_release(struct gendisk *disk, fmode_t mode) static int mspro_block_bd_release(struct gendisk *disk, fmode_t mode)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&mspro_block_mutex);
ret = mspro_block_disk_release(disk); ret = mspro_block_disk_release(disk);
unlock_kernel(); mutex_unlock(&mspro_block_mutex);
return ret; return ret;
} }

15
drivers/message/fusion/mptctl.c
View File

@ -54,7 +54,7 @@
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/delay.h> /* for mdelay */ #include <linux/delay.h> /* for mdelay */
#include <linux/miscdevice.h> #include <linux/miscdevice.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/compat.h> #include <linux/compat.h>
#include <asm/io.h> #include <asm/io.h>
@ -83,6 +83,7 @@ MODULE_VERSION(my_VERSION);
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
static DEFINE_MUTEX(mpctl_mutex);
static u8 mptctl_id = MPT_MAX_PROTOCOL_DRIVERS; static u8 mptctl_id = MPT_MAX_PROTOCOL_DRIVERS;
static u8 mptctl_taskmgmt_id = MPT_MAX_PROTOCOL_DRIVERS; static u8 mptctl_taskmgmt_id = MPT_MAX_PROTOCOL_DRIVERS;
@ -601,12 +602,12 @@ mptctl_fasync(int fd, struct file *filep, int mode)
MPT_ADAPTER *ioc; MPT_ADAPTER *ioc;
int ret; int ret;
lock_kernel(); mutex_lock(&mpctl_mutex);
list_for_each_entry(ioc, &ioc_list, list) list_for_each_entry(ioc, &ioc_list, list)
ioc->aen_event_read_flag=0; ioc->aen_event_read_flag=0;
ret = fasync_helper(fd, filep, mode, &async_queue); ret = fasync_helper(fd, filep, mode, &async_queue);
unlock_kernel(); mutex_unlock(&mpctl_mutex);
return ret; return ret;
} }
@ -698,9 +699,9 @@ static long
mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg) mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{ {
long ret; long ret;
lock_kernel(); mutex_lock(&mpctl_mutex);
ret = __mptctl_ioctl(file, cmd, arg); ret = __mptctl_ioctl(file, cmd, arg);
unlock_kernel(); mutex_unlock(&mpctl_mutex);
return ret; return ret;
} }
@ -2926,7 +2927,7 @@ compat_mpt_command(struct file *filp, unsigned int cmd,
static long compat_mpctl_ioctl(struct file *f, unsigned int cmd, unsigned long arg) static long compat_mpctl_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
{ {
long ret; long ret;
lock_kernel(); mutex_lock(&mpctl_mutex);
switch (cmd) { switch (cmd) {
case MPTIOCINFO: case MPTIOCINFO:
case MPTIOCINFO1: case MPTIOCINFO1:
@ -2951,7 +2952,7 @@ static long compat_mpctl_ioctl(struct file *f, unsigned int cmd, unsigned long a
ret = -ENOIOCTLCMD; ret = -ENOIOCTLCMD;
break; break;
} }
unlock_kernel(); mutex_unlock(&mpctl_mutex);
return ret; return ret;
} }

15
drivers/message/i2o/i2o_block.c
View File

@ -53,7 +53,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/i2o.h> #include <linux/i2o.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/mempool.h> #include <linux/mempool.h>
@ -69,6 +69,7 @@
#define OSM_VERSION "1.325" #define OSM_VERSION "1.325"
#define OSM_DESCRIPTION "I2O Block Device OSM" #define OSM_DESCRIPTION "I2O Block Device OSM"
static DEFINE_MUTEX(i2o_block_mutex);
static struct i2o_driver i2o_block_driver; static struct i2o_driver i2o_block_driver;
/* global Block OSM request mempool */ /* global Block OSM request mempool */
@ -578,7 +579,7 @@ static int i2o_block_open(struct block_device *bdev, fmode_t mode)
if (!dev->i2o_dev) if (!dev->i2o_dev)
return -ENODEV; return -ENODEV;
lock_kernel(); mutex_lock(&i2o_block_mutex);
if (dev->power > 0x1f) if (dev->power > 0x1f)
i2o_block_device_power(dev, 0x02); i2o_block_device_power(dev, 0x02);
@ -587,7 +588,7 @@ static int i2o_block_open(struct block_device *bdev, fmode_t mode)
i2o_block_device_lock(dev->i2o_dev, -1); i2o_block_device_lock(dev->i2o_dev, -1);
osm_debug("Ready.\n"); osm_debug("Ready.\n");
unlock_kernel(); mutex_unlock(&i2o_block_mutex);
return 0; return 0;
}; };
@ -618,7 +619,7 @@ static int i2o_block_release(struct gendisk *disk, fmode_t mode)
if (!dev->i2o_dev) if (!dev->i2o_dev)
return 0; return 0;
lock_kernel(); mutex_lock(&i2o_block_mutex);
i2o_block_device_flush(dev->i2o_dev); i2o_block_device_flush(dev->i2o_dev);
i2o_block_device_unlock(dev->i2o_dev, -1); i2o_block_device_unlock(dev->i2o_dev, -1);
@ -629,7 +630,7 @@ static int i2o_block_release(struct gendisk *disk, fmode_t mode)
operation = 0x24; operation = 0x24;
i2o_block_device_power(dev, operation); i2o_block_device_power(dev, operation);
unlock_kernel(); mutex_unlock(&i2o_block_mutex);
return 0; return 0;
} }
@ -664,7 +665,7 @@ static int i2o_block_ioctl(struct block_device *bdev, fmode_t mode,
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
return -EPERM; return -EPERM;
lock_kernel(); mutex_lock(&i2o_block_mutex);
switch (cmd) { switch (cmd) {
case BLKI2OGRSTRAT: case BLKI2OGRSTRAT:
ret = put_user(dev->rcache, (int __user *)arg); ret = put_user(dev->rcache, (int __user *)arg);
@ -688,7 +689,7 @@ static int i2o_block_ioctl(struct block_device *bdev, fmode_t mode,
ret = 0; ret = 0;
break; break;
} }
unlock_kernel(); mutex_unlock(&i2o_block_mutex);
return ret; return ret;
}; };

23
drivers/message/i2o/i2o_config.c
View File

@ -31,7 +31,7 @@
*/ */
#include <linux/miscdevice.h> #include <linux/miscdevice.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/compat.h> #include <linux/compat.h>
#include <linux/slab.h> #include <linux/slab.h>
@ -41,6 +41,7 @@
#define SG_TABLESIZE 30 #define SG_TABLESIZE 30
static DEFINE_MUTEX(i2o_cfg_mutex);
static long i2o_cfg_ioctl(struct file *, unsigned int, unsigned long); static long i2o_cfg_ioctl(struct file *, unsigned int, unsigned long);
static spinlock_t i2o_config_lock; static spinlock_t i2o_config_lock;
@ -741,7 +742,7 @@ static long i2o_cfg_compat_ioctl(struct file *file, unsigned cmd,
unsigned long arg) unsigned long arg)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&i2o_cfg_mutex);
switch (cmd) { switch (cmd) {
case I2OGETIOPS: case I2OGETIOPS:
ret = i2o_cfg_ioctl(file, cmd, arg); ret = i2o_cfg_ioctl(file, cmd, arg);
@ -753,7 +754,7 @@ static long i2o_cfg_compat_ioctl(struct file *file, unsigned cmd,
ret = -ENOIOCTLCMD; ret = -ENOIOCTLCMD;
break; break;
} }
unlock_kernel(); mutex_unlock(&i2o_cfg_mutex);
return ret; return ret;
} }
@ -981,7 +982,7 @@ static long i2o_cfg_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&i2o_cfg_mutex);
switch (cmd) { switch (cmd) {
case I2OGETIOPS: case I2OGETIOPS:
ret = i2o_cfg_getiops(arg); ret = i2o_cfg_getiops(arg);
@ -1037,7 +1038,7 @@ static long i2o_cfg_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
osm_debug("unknown ioctl called!\n"); osm_debug("unknown ioctl called!\n");
ret = -EINVAL; ret = -EINVAL;
} }
unlock_kernel(); mutex_unlock(&i2o_cfg_mutex);
return ret; return ret;
} }
@ -1051,7 +1052,7 @@ static int cfg_open(struct inode *inode, struct file *file)
if (!tmp) if (!tmp)
return -ENOMEM; return -ENOMEM;
lock_kernel(); mutex_lock(&i2o_cfg_mutex);
file->private_data = (void *)(i2o_cfg_info_id++); file->private_data = (void *)(i2o_cfg_info_id++);
tmp->fp = file; tmp->fp = file;
tmp->fasync = NULL; tmp->fasync = NULL;
@ -1065,7 +1066,7 @@ static int cfg_open(struct inode *inode, struct file *file)
spin_lock_irqsave(&i2o_config_lock, flags); spin_lock_irqsave(&i2o_config_lock, flags);
open_files = tmp; open_files = tmp;
spin_unlock_irqrestore(&i2o_config_lock, flags); spin_unlock_irqrestore(&i2o_config_lock, flags);
unlock_kernel(); mutex_unlock(&i2o_cfg_mutex);
return 0; return 0;
} }
@ -1076,14 +1077,14 @@ static int cfg_fasync(int fd, struct file *fp, int on)
struct i2o_cfg_info *p; struct i2o_cfg_info *p;
int ret = -EBADF; int ret = -EBADF;
lock_kernel(); mutex_lock(&i2o_cfg_mutex);
for (p = open_files; p; p = p->next) for (p = open_files; p; p = p->next)
if (p->q_id == id) if (p->q_id == id)
break; break;
if (p) if (p)
ret = fasync_helper(fd, fp, on, &p->fasync); ret = fasync_helper(fd, fp, on, &p->fasync);
unlock_kernel(); mutex_unlock(&i2o_cfg_mutex);
return ret; return ret;
} }
@ -1093,7 +1094,7 @@ static int cfg_release(struct inode *inode, struct file *file)
struct i2o_cfg_info *p, **q; struct i2o_cfg_info *p, **q;
unsigned long flags; unsigned long flags;
lock_kernel(); mutex_lock(&i2o_cfg_mutex);
spin_lock_irqsave(&i2o_config_lock, flags); spin_lock_irqsave(&i2o_config_lock, flags);
for (q = &open_files; (p = *q) != NULL; q = &p->next) { for (q = &open_files; (p = *q) != NULL; q = &p->next) {
if (p->q_id == id) { if (p->q_id == id) {
@ -1103,7 +1104,7 @@ static int cfg_release(struct inode *inode, struct file *file)
} }
} }
spin_unlock_irqrestore(&i2o_config_lock, flags); spin_unlock_irqrestore(&i2o_config_lock, flags);
unlock_kernel(); mutex_unlock(&i2o_cfg_mutex);
return 0; return 0;
} }

11
drivers/misc/phantom.c
View File

@ -24,7 +24,7 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/phantom.h> #include <linux/phantom.h>
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <asm/atomic.h> #include <asm/atomic.h>
#include <asm/io.h> #include <asm/io.h>
@ -38,6 +38,7 @@
#define PHB_RUNNING 1 #define PHB_RUNNING 1
#define PHB_NOT_OH 2 #define PHB_NOT_OH 2
static DEFINE_MUTEX(phantom_mutex);
static struct class *phantom_class; static struct class *phantom_class;
static int phantom_major; static int phantom_major;
@ -215,17 +216,17 @@ static int phantom_open(struct inode *inode, struct file *file)
struct phantom_device *dev = container_of(inode->i_cdev, struct phantom_device *dev = container_of(inode->i_cdev,
struct phantom_device, cdev); struct phantom_device, cdev);
lock_kernel(); mutex_lock(&phantom_mutex);
nonseekable_open(inode, file); nonseekable_open(inode, file);
if (mutex_lock_interruptible(&dev->open_lock)) { if (mutex_lock_interruptible(&dev->open_lock)) {
unlock_kernel(); mutex_unlock(&phantom_mutex);
return -ERESTARTSYS; return -ERESTARTSYS;
} }
if (dev->opened) { if (dev->opened) {
mutex_unlock(&dev->open_lock); mutex_unlock(&dev->open_lock);
unlock_kernel(); mutex_unlock(&phantom_mutex);
return -EINVAL; return -EINVAL;
} }
@ -236,7 +237,7 @@ static int phantom_open(struct inode *inode, struct file *file)
atomic_set(&dev->counter, 0); atomic_set(&dev->counter, 0);
dev->opened++; dev->opened++;
mutex_unlock(&dev->open_lock); mutex_unlock(&dev->open_lock);
unlock_kernel(); mutex_unlock(&phantom_mutex);
return 0; return 0;
} }

10
drivers/mmc/card/block.c
View File

@ -29,7 +29,6 @@
#include <linux/kdev_t.h> #include <linux/kdev_t.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/smp_lock.h>
#include <linux/scatterlist.h> #include <linux/scatterlist.h>
#include <linux/string_helpers.h> #include <linux/string_helpers.h>
@ -51,6 +50,7 @@ MODULE_ALIAS("mmc:block");
#define MMC_SHIFT 3 #define MMC_SHIFT 3
#define MMC_NUM_MINORS (256 >> MMC_SHIFT) #define MMC_NUM_MINORS (256 >> MMC_SHIFT)
static DEFINE_MUTEX(block_mutex);
static DECLARE_BITMAP(dev_use, MMC_NUM_MINORS); static DECLARE_BITMAP(dev_use, MMC_NUM_MINORS);
/* /*
@ -108,7 +108,7 @@ static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk); struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk);
int ret = -ENXIO; int ret = -ENXIO;
lock_kernel(); mutex_lock(&block_mutex);
if (md) { if (md) {
if (md->usage == 2) if (md->usage == 2)
check_disk_change(bdev); check_disk_change(bdev);
@ -119,7 +119,7 @@ static int mmc_blk_open(struct block_device *bdev, fmode_t mode)
ret = -EROFS; ret = -EROFS;
} }
} }
unlock_kernel(); mutex_unlock(&block_mutex);
return ret; return ret;
} }
@ -128,9 +128,9 @@ static int mmc_blk_release(struct gendisk *disk, fmode_t mode)
{ {
struct mmc_blk_data *md = disk->private_data; struct mmc_blk_data *md = disk->private_data;
lock_kernel(); mutex_lock(&block_mutex);
mmc_blk_put(md); mmc_blk_put(md);
unlock_kernel(); mutex_unlock(&block_mutex);
return 0; return 0;
} }

14
drivers/mtd/mtd_blkdevs.c
View File

@ -29,7 +29,6 @@
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/blkpg.h> #include <linux/blkpg.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/smp_lock.h>
#include <linux/hdreg.h> #include <linux/hdreg.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/mutex.h> #include <linux/mutex.h>
@ -38,6 +37,7 @@
#include "mtdcore.h" #include "mtdcore.h"
static DEFINE_MUTEX(mtd_blkdevs_mutex);
static LIST_HEAD(blktrans_majors); static LIST_HEAD(blktrans_majors);
static DEFINE_MUTEX(blktrans_ref_mutex); static DEFINE_MUTEX(blktrans_ref_mutex);
@ -181,7 +181,7 @@ static int blktrans_open(struct block_device *bdev, fmode_t mode)
if (!dev) if (!dev)
return -ERESTARTSYS; /* FIXME: busy loop! -arnd*/ return -ERESTARTSYS; /* FIXME: busy loop! -arnd*/
lock_kernel(); mutex_lock(&mtd_blkdevs_mutex);
mutex_lock(&dev->lock); mutex_lock(&dev->lock);
if (!dev->mtd) { if (!dev->mtd) {
@ -198,7 +198,7 @@ static int blktrans_open(struct block_device *bdev, fmode_t mode)
unlock: unlock:
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
blktrans_dev_put(dev); blktrans_dev_put(dev);
unlock_kernel(); mutex_unlock(&mtd_blkdevs_mutex);
return ret; return ret;
} }
@ -210,7 +210,7 @@ static int blktrans_release(struct gendisk *disk, fmode_t mode)
if (!dev) if (!dev)
return ret; return ret;
lock_kernel(); mutex_lock(&mtd_blkdevs_mutex);
mutex_lock(&dev->lock); mutex_lock(&dev->lock);
/* Release one reference, we sure its not the last one here*/ /* Release one reference, we sure its not the last one here*/
@ -223,7 +223,7 @@ static int blktrans_release(struct gendisk *disk, fmode_t mode)
unlock: unlock:
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
blktrans_dev_put(dev); blktrans_dev_put(dev);
unlock_kernel(); mutex_unlock(&mtd_blkdevs_mutex);
return ret; return ret;
} }
@ -256,7 +256,7 @@ static int blktrans_ioctl(struct block_device *bdev, fmode_t mode,
if (!dev) if (!dev)
return ret; return ret;
lock_kernel(); mutex_lock(&mtd_blkdevs_mutex);
mutex_lock(&dev->lock); mutex_lock(&dev->lock);
if (!dev->mtd) if (!dev->mtd)
@ -271,7 +271,7 @@ static int blktrans_ioctl(struct block_device *bdev, fmode_t mode,
} }
unlock: unlock:
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
unlock_kernel(); mutex_unlock(&mtd_blkdevs_mutex);
blktrans_dev_put(dev); blktrans_dev_put(dev);
return ret; return ret;
} }

15
drivers/mtd/mtdchar.c
View File

@ -26,7 +26,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/backing-dev.h> #include <linux/backing-dev.h>
#include <linux/compat.h> #include <linux/compat.h>
#include <linux/mount.h> #include <linux/mount.h>
@ -37,6 +37,7 @@
#include <asm/uaccess.h> #include <asm/uaccess.h>
#define MTD_INODE_FS_MAGIC 0x11307854 #define MTD_INODE_FS_MAGIC 0x11307854
static DEFINE_MUTEX(mtd_mutex);
static struct vfsmount *mtd_inode_mnt __read_mostly; static struct vfsmount *mtd_inode_mnt __read_mostly;
/* /*
@ -90,7 +91,7 @@ static int mtd_open(struct inode *inode, struct file *file)
if ((file->f_mode & FMODE_WRITE) && (minor & 1)) if ((file->f_mode & FMODE_WRITE) && (minor & 1))
return -EACCES; return -EACCES;
lock_kernel(); mutex_lock(&mtd_mutex);
mtd = get_mtd_device(NULL, devnum); mtd = get_mtd_device(NULL, devnum);
if (IS_ERR(mtd)) { if (IS_ERR(mtd)) {
@ -138,7 +139,7 @@ static int mtd_open(struct inode *inode, struct file *file)
file->private_data = mfi; file->private_data = mfi;
out: out:
unlock_kernel(); mutex_unlock(&mtd_mutex);
return ret; return ret;
} /* mtd_open */ } /* mtd_open */
@ -866,9 +867,9 @@ static long mtd_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&mtd_mutex);
ret = mtd_ioctl(file, cmd, arg); ret = mtd_ioctl(file, cmd, arg);
unlock_kernel(); mutex_unlock(&mtd_mutex);
return ret; return ret;
} }
@ -892,7 +893,7 @@ static long mtd_compat_ioctl(struct file *file, unsigned int cmd,
void __user *argp = compat_ptr(arg); void __user *argp = compat_ptr(arg);
int ret = 0; int ret = 0;
lock_kernel(); mutex_lock(&mtd_mutex);
switch (cmd) { switch (cmd) {
case MEMWRITEOOB32: case MEMWRITEOOB32:
@ -927,7 +928,7 @@ static long mtd_compat_ioctl(struct file *file, unsigned int cmd,
ret = mtd_ioctl(file, cmd, (unsigned long)argp); ret = mtd_ioctl(file, cmd, (unsigned long)argp);
} }
unlock_kernel(); mutex_unlock(&mtd_mutex);
return ret; return ret;
} }

13
drivers/pci/hotplug/cpqphp_sysfs.c
View File

@ -34,10 +34,11 @@
#include <linux/workqueue.h> #include <linux/workqueue.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/pci_hotplug.h> #include <linux/pci_hotplug.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/debugfs.h> #include <linux/debugfs.h>
#include "cpqphp.h" #include "cpqphp.h"
static DEFINE_MUTEX(cpqphp_mutex);
static int show_ctrl (struct controller *ctrl, char *buf) static int show_ctrl (struct controller *ctrl, char *buf)
{ {
char *out = buf; char *out = buf;
@ -147,7 +148,7 @@ static int open(struct inode *inode, struct file *file)
struct ctrl_dbg *dbg; struct ctrl_dbg *dbg;
int retval = -ENOMEM; int retval = -ENOMEM;
lock_kernel(); mutex_lock(&cpqphp_mutex);
dbg = kmalloc(sizeof(*dbg), GFP_KERNEL); dbg = kmalloc(sizeof(*dbg), GFP_KERNEL);
if (!dbg) if (!dbg)
goto exit; goto exit;
@ -160,7 +161,7 @@ static int open(struct inode *inode, struct file *file)
file->private_data = dbg; file->private_data = dbg;
retval = 0; retval = 0;
exit: exit:
unlock_kernel(); mutex_unlock(&cpqphp_mutex);
return retval; return retval;
} }
@ -169,7 +170,7 @@ static loff_t lseek(struct file *file, loff_t off, int whence)
struct ctrl_dbg *dbg; struct ctrl_dbg *dbg;
loff_t new = -1; loff_t new = -1;
lock_kernel(); mutex_lock(&cpqphp_mutex);
dbg = file->private_data; dbg = file->private_data;
switch (whence) { switch (whence) {
@ -181,10 +182,10 @@ static loff_t lseek(struct file *file, loff_t off, int whence)
break; break;
} }
if (new < 0 || new > dbg->size) { if (new < 0 || new > dbg->size) {
unlock_kernel(); mutex_unlock(&cpqphp_mutex);
return -EINVAL; return -EINVAL;
} }
unlock_kernel(); mutex_unlock(&cpqphp_mutex);
return (file->f_pos = new); return (file->f_pos = new);
} }

13
drivers/rtc/rtc-m41t80.c
View File

@ -20,7 +20,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/rtc.h> #include <linux/rtc.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/string.h> #include <linux/string.h>
#ifdef CONFIG_RTC_DRV_M41T80_WDT #ifdef CONFIG_RTC_DRV_M41T80_WDT
#include <linux/fs.h> #include <linux/fs.h>
@ -68,6 +68,7 @@
#define DRV_VERSION "0.05" #define DRV_VERSION "0.05"
static DEFINE_MUTEX(m41t80_rtc_mutex);
static const struct i2c_device_id m41t80_id[] = { static const struct i2c_device_id m41t80_id[] = {
{ "m41t62", M41T80_FEATURE_SQ | M41T80_FEATURE_SQ_ALT }, { "m41t62", M41T80_FEATURE_SQ | M41T80_FEATURE_SQ_ALT },
{ "m41t65", M41T80_FEATURE_HT | M41T80_FEATURE_WD }, { "m41t65", M41T80_FEATURE_HT | M41T80_FEATURE_WD },
@ -677,9 +678,9 @@ static long wdt_unlocked_ioctl(struct file *file, unsigned int cmd,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&m41t80_rtc_mutex);
ret = wdt_ioctl(file, cmd, arg); ret = wdt_ioctl(file, cmd, arg);
unlock_kernel(); mutex_unlock(&m41t80_rtc_mutex);
return ret; return ret;
} }
@ -693,16 +694,16 @@ static long wdt_unlocked_ioctl(struct file *file, unsigned int cmd,
static int wdt_open(struct inode *inode, struct file *file) static int wdt_open(struct inode *inode, struct file *file)
{ {
if (MINOR(inode->i_rdev) == WATCHDOG_MINOR) { if (MINOR(inode->i_rdev) == WATCHDOG_MINOR) {
lock_kernel(); mutex_lock(&m41t80_rtc_mutex);
if (test_and_set_bit(0, &wdt_is_open)) { if (test_and_set_bit(0, &wdt_is_open)) {
unlock_kernel(); mutex_unlock(&m41t80_rtc_mutex);
return -EBUSY; return -EBUSY;
} }
/* /*
* Activate * Activate
*/ */
wdt_is_open = 1; wdt_is_open = 1;
unlock_kernel(); mutex_unlock(&m41t80_rtc_mutex);
return nonseekable_open(inode, file); return nonseekable_open(inode, file);
} }
return -ENODEV; return -ENODEV;

13
drivers/s390/char/tape_block.c
View File

@ -16,7 +16,7 @@
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#include <linux/kernel.h> #include <linux/kernel.h>
@ -45,6 +45,7 @@
/* /*
* file operation structure for tape block frontend * file operation structure for tape block frontend
*/ */
static DEFINE_MUTEX(tape_block_mutex);
static int tapeblock_open(struct block_device *, fmode_t); static int tapeblock_open(struct block_device *, fmode_t);
static int tapeblock_release(struct gendisk *, fmode_t); static int tapeblock_release(struct gendisk *, fmode_t);
static int tapeblock_medium_changed(struct gendisk *); static int tapeblock_medium_changed(struct gendisk *);
@ -361,7 +362,7 @@ tapeblock_open(struct block_device *bdev, fmode_t mode)
struct tape_device * device; struct tape_device * device;
int rc; int rc;
lock_kernel(); mutex_lock(&tape_block_mutex);
device = tape_get_device(disk->private_data); device = tape_get_device(disk->private_data);
if (device->required_tapemarks) { if (device->required_tapemarks) {
@ -385,14 +386,14 @@ tapeblock_open(struct block_device *bdev, fmode_t mode)
* is called. * is called.
*/ */
tape_state_set(device, TS_BLKUSE); tape_state_set(device, TS_BLKUSE);
unlock_kernel(); mutex_unlock(&tape_block_mutex);
return 0; return 0;
release: release:
tape_release(device); tape_release(device);
put_device: put_device:
tape_put_device(device); tape_put_device(device);
unlock_kernel(); mutex_unlock(&tape_block_mutex);
return rc; return rc;
} }
@ -407,11 +408,11 @@ tapeblock_release(struct gendisk *disk, fmode_t mode)
{ {
struct tape_device *device = disk->private_data; struct tape_device *device = disk->private_data;
lock_kernel(); mutex_lock(&tape_block_mutex);
tape_state_set(device, TS_IN_USE); tape_state_set(device, TS_IN_USE);
tape_release(device); tape_release(device);
tape_put_device(device); tape_put_device(device);
unlock_kernel(); mutex_unlock(&tape_block_mutex);
return 0; return 0;
} }

24
drivers/sbus/char/jsflash.c
View File

@ -27,7 +27,7 @@
*/ */
#include <linux/module.h> #include <linux/module.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/types.h> #include <linux/types.h>
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/miscdevice.h> #include <linux/miscdevice.h>
@ -68,6 +68,8 @@
#define JSF_PART_BITS 2 /* 2 bits of minors to cover JSF_NPART */ #define JSF_PART_BITS 2 /* 2 bits of minors to cover JSF_NPART */
#define JSF_PART_MASK 0x3 /* 2 bits mask */ #define JSF_PART_MASK 0x3 /* 2 bits mask */
static DEFINE_MUTEX(jsf_mutex);
/* /*
* Access functions. * Access functions.
* We could ioremap(), but it's easier this way. * We could ioremap(), but it's easier this way.
@ -225,7 +227,7 @@ static loff_t jsf_lseek(struct file * file, loff_t offset, int orig)
{ {
loff_t ret; loff_t ret;
lock_kernel(); mutex_lock(&jsf_mutex);
switch (orig) { switch (orig) {
case 0: case 0:
file->f_pos = offset; file->f_pos = offset;
@ -238,7 +240,7 @@ static loff_t jsf_lseek(struct file * file, loff_t offset, int orig)
default: default:
ret = -EINVAL; ret = -EINVAL;
} }
unlock_kernel(); mutex_unlock(&jsf_mutex);
return ret; return ret;
} }
@ -384,18 +386,18 @@ static int jsf_ioctl_program(void __user *arg)
static long jsf_ioctl(struct file *f, unsigned int cmd, unsigned long arg) static long jsf_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
{ {
lock_kernel(); mutex_lock(&jsf_mutex);
int error = -ENOTTY; int error = -ENOTTY;
void __user *argp = (void __user *)arg; void __user *argp = (void __user *)arg;
if (!capable(CAP_SYS_ADMIN)) { if (!capable(CAP_SYS_ADMIN)) {
unlock_kernel(); mutex_unlock(&jsf_mutex);
return -EPERM; return -EPERM;
} }
switch (cmd) { switch (cmd) {
case JSFLASH_IDENT: case JSFLASH_IDENT:
if (copy_to_user(argp, &jsf0.id, JSFIDSZ)) { if (copy_to_user(argp, &jsf0.id, JSFIDSZ)) {
unlock_kernel(); mutex_unlock(&jsf_mutex);
return -EFAULT; return -EFAULT;
} }
break; break;
@ -407,7 +409,7 @@ static long jsf_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
break; break;
} }
unlock_kernel(); mutex_unlock(&jsf_mutex);
return error; return error;
} }
@ -418,17 +420,17 @@ static int jsf_mmap(struct file * file, struct vm_area_struct * vma)
static int jsf_open(struct inode * inode, struct file * filp) static int jsf_open(struct inode * inode, struct file * filp)
{ {
lock_kernel(); mutex_lock(&jsf_mutex);
if (jsf0.base == 0) { if (jsf0.base == 0) {
unlock_kernel(); mutex_unlock(&jsf_mutex);
return -ENXIO; return -ENXIO;
} }
if (test_and_set_bit(0, (void *)&jsf0.busy) != 0) { if (test_and_set_bit(0, (void *)&jsf0.busy) != 0) {
unlock_kernel(); mutex_unlock(&jsf_mutex);
return -EBUSY; return -EBUSY;
} }
unlock_kernel(); mutex_unlock(&jsf_mutex);
return 0; /* XXX What security? */ return 0; /* XXX What security? */
} }

7
drivers/scsi/3w-9xxx.c
View File

@ -92,7 +92,6 @@
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/time.h> #include <linux/time.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/smp_lock.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/irq.h> #include <asm/irq.h>
@ -105,6 +104,7 @@
/* Globals */ /* Globals */
#define TW_DRIVER_VERSION "2.26.02.014" #define TW_DRIVER_VERSION "2.26.02.014"
static DEFINE_MUTEX(twa_chrdev_mutex);
static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT]; static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT];
static unsigned int twa_device_extension_count; static unsigned int twa_device_extension_count;
static int twa_major = -1; static int twa_major = -1;
@ -658,7 +658,7 @@ static long twa_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long
int retval = TW_IOCTL_ERROR_OS_EFAULT; int retval = TW_IOCTL_ERROR_OS_EFAULT;
void __user *argp = (void __user *)arg; void __user *argp = (void __user *)arg;
lock_kernel(); mutex_lock(&twa_chrdev_mutex);
/* Only let one of these through at a time */ /* Only let one of these through at a time */
if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) { if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
@ -879,7 +879,7 @@ out3:
out2: out2:
mutex_unlock(&tw_dev->ioctl_lock); mutex_unlock(&tw_dev->ioctl_lock);
out: out:
unlock_kernel(); mutex_unlock(&twa_chrdev_mutex);
return retval; return retval;
} /* End twa_chrdev_ioctl() */ } /* End twa_chrdev_ioctl() */
@ -890,7 +890,6 @@ static int twa_chrdev_open(struct inode *inode, struct file *file)
unsigned int minor_number; unsigned int minor_number;
int retval = TW_IOCTL_ERROR_OS_ENODEV; int retval = TW_IOCTL_ERROR_OS_ENODEV;
cycle_kernel_lock();
minor_number = iminor(inode); minor_number = iminor(inode);
if (minor_number >= twa_device_extension_count) if (minor_number >= twa_device_extension_count)
goto out; goto out;

7
drivers/scsi/3w-sas.c
View File

@ -64,7 +64,6 @@
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/time.h> #include <linux/time.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/smp_lock.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/irq.h> #include <asm/irq.h>
@ -77,6 +76,7 @@
/* Globals */ /* Globals */
#define TW_DRIVER_VERSION "3.26.02.000" #define TW_DRIVER_VERSION "3.26.02.000"
static DEFINE_MUTEX(twl_chrdev_mutex);
static TW_Device_Extension *twl_device_extension_list[TW_MAX_SLOT]; static TW_Device_Extension *twl_device_extension_list[TW_MAX_SLOT];
static unsigned int twl_device_extension_count; static unsigned int twl_device_extension_count;
static int twl_major = -1; static int twl_major = -1;
@ -764,7 +764,7 @@ static long twl_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long
int retval = -EFAULT; int retval = -EFAULT;
void __user *argp = (void __user *)arg; void __user *argp = (void __user *)arg;
lock_kernel(); mutex_lock(&twl_chrdev_mutex);
/* Only let one of these through at a time */ /* Only let one of these through at a time */
if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) { if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
@ -861,7 +861,7 @@ out3:
out2: out2:
mutex_unlock(&tw_dev->ioctl_lock); mutex_unlock(&tw_dev->ioctl_lock);
out: out:
unlock_kernel(); mutex_unlock(&twl_chrdev_mutex);
return retval; return retval;
} /* End twl_chrdev_ioctl() */ } /* End twl_chrdev_ioctl() */
@ -876,7 +876,6 @@ static int twl_chrdev_open(struct inode *inode, struct file *file)
goto out; goto out;
} }
cycle_kernel_lock();
minor_number = iminor(inode); minor_number = iminor(inode);
if (minor_number >= twl_device_extension_count) if (minor_number >= twl_device_extension_count)
goto out; goto out;

9
drivers/scsi/3w-xxxx.c
View File

@ -199,7 +199,6 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/reboot.h> #include <linux/reboot.h>
#include <linux/smp_lock.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
@ -221,6 +220,7 @@
/* Globals */ /* Globals */
#define TW_DRIVER_VERSION "1.26.02.003" #define TW_DRIVER_VERSION "1.26.02.003"
static DEFINE_MUTEX(tw_mutex);
static TW_Device_Extension *tw_device_extension_list[TW_MAX_SLOT]; static TW_Device_Extension *tw_device_extension_list[TW_MAX_SLOT];
static int tw_device_extension_count = 0; static int tw_device_extension_count = 0;
static int twe_major = -1; static int twe_major = -1;
@ -900,10 +900,10 @@ static long tw_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long a
dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl()\n"); dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl()\n");
lock_kernel(); mutex_lock(&tw_mutex);
/* Only let one of these through at a time */ /* Only let one of these through at a time */
if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) { if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
unlock_kernel(); mutex_unlock(&tw_mutex);
return -EINTR; return -EINTR;
} }
@ -1034,7 +1034,7 @@ out2:
dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, cpu_addr, dma_handle); dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, cpu_addr, dma_handle);
out: out:
mutex_unlock(&tw_dev->ioctl_lock); mutex_unlock(&tw_dev->ioctl_lock);
unlock_kernel(); mutex_unlock(&tw_mutex);
return retval; return retval;
} /* End tw_chrdev_ioctl() */ } /* End tw_chrdev_ioctl() */
@ -1044,7 +1044,6 @@ static int tw_chrdev_open(struct inode *inode, struct file *file)
{ {
unsigned int minor_number; unsigned int minor_number;
cycle_kernel_lock();
dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_open()\n"); dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_open()\n");
minor_number = iminor(inode); minor_number = iminor(inode);

15
drivers/scsi/aacraid/linit.c
View File

@ -38,7 +38,7 @@
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/syscalls.h> #include <linux/syscalls.h>
#include <linux/delay.h> #include <linux/delay.h>
@ -76,6 +76,7 @@ MODULE_DESCRIPTION("Dell PERC2, 2/Si, 3/Si, 3/Di, "
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_VERSION(AAC_DRIVER_FULL_VERSION); MODULE_VERSION(AAC_DRIVER_FULL_VERSION);
static DEFINE_MUTEX(aac_mutex);
static LIST_HEAD(aac_devices); static LIST_HEAD(aac_devices);
static int aac_cfg_major = -1; static int aac_cfg_major = -1;
char aac_driver_version[] = AAC_DRIVER_FULL_VERSION; char aac_driver_version[] = AAC_DRIVER_FULL_VERSION;
@ -678,7 +679,7 @@ static int aac_cfg_open(struct inode *inode, struct file *file)
unsigned minor_number = iminor(inode); unsigned minor_number = iminor(inode);
int err = -ENODEV; int err = -ENODEV;
lock_kernel(); /* BKL pushdown: nothing else protects this list */ mutex_lock(&aac_mutex); /* BKL pushdown: nothing else protects this list */
list_for_each_entry(aac, &aac_devices, entry) { list_for_each_entry(aac, &aac_devices, entry) {
if (aac->id == minor_number) { if (aac->id == minor_number) {
file->private_data = aac; file->private_data = aac;
@ -686,7 +687,7 @@ static int aac_cfg_open(struct inode *inode, struct file *file)
break; break;
} }
} }
unlock_kernel(); mutex_unlock(&aac_mutex);
return err; return err;
} }
@ -711,9 +712,9 @@ static long aac_cfg_ioctl(struct file *file,
int ret; int ret;
if (!capable(CAP_SYS_RAWIO)) if (!capable(CAP_SYS_RAWIO))
return -EPERM; return -EPERM;
lock_kernel(); mutex_lock(&aac_mutex);
ret = aac_do_ioctl(file->private_data, cmd, (void __user *)arg); ret = aac_do_ioctl(file->private_data, cmd, (void __user *)arg);
unlock_kernel(); mutex_unlock(&aac_mutex);
return ret; return ret;
} }
@ -722,7 +723,7 @@ static long aac_cfg_ioctl(struct file *file,
static long aac_compat_do_ioctl(struct aac_dev *dev, unsigned cmd, unsigned long arg) static long aac_compat_do_ioctl(struct aac_dev *dev, unsigned cmd, unsigned long arg)
{ {
long ret; long ret;
lock_kernel(); mutex_lock(&aac_mutex);
switch (cmd) { switch (cmd) {
case FSACTL_MINIPORT_REV_CHECK: case FSACTL_MINIPORT_REV_CHECK:
case FSACTL_SENDFIB: case FSACTL_SENDFIB:
@ -756,7 +757,7 @@ static long aac_compat_do_ioctl(struct aac_dev *dev, unsigned cmd, unsigned long
ret = -ENOIOCTLCMD; ret = -ENOIOCTLCMD;
break; break;
} }
unlock_kernel(); mutex_unlock(&aac_mutex);
return ret; return ret;
} }

8
drivers/scsi/ch.c
View File

@ -22,7 +22,6 @@
#include <linux/chio.h> /* here are all the ioctls */ #include <linux/chio.h> /* here are all the ioctls */
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/idr.h> #include <linux/idr.h>
#include <linux/smp_lock.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <scsi/scsi.h> #include <scsi/scsi.h>
@ -44,6 +43,7 @@ MODULE_LICENSE("GPL");
MODULE_ALIAS_CHARDEV_MAJOR(SCSI_CHANGER_MAJOR); MODULE_ALIAS_CHARDEV_MAJOR(SCSI_CHANGER_MAJOR);
MODULE_ALIAS_SCSI_DEVICE(TYPE_MEDIUM_CHANGER); MODULE_ALIAS_SCSI_DEVICE(TYPE_MEDIUM_CHANGER);
static DEFINE_MUTEX(ch_mutex);
static int init = 1; static int init = 1;
module_param(init, int, 0444); module_param(init, int, 0444);
MODULE_PARM_DESC(init, \ MODULE_PARM_DESC(init, \
@ -581,19 +581,19 @@ ch_open(struct inode *inode, struct file *file)
scsi_changer *ch; scsi_changer *ch;
int minor = iminor(inode); int minor = iminor(inode);
lock_kernel(); mutex_lock(&ch_mutex);
spin_lock(&ch_index_lock); spin_lock(&ch_index_lock);
ch = idr_find(&ch_index_idr, minor); ch = idr_find(&ch_index_idr, minor);
if (NULL == ch || scsi_device_get(ch->device)) { if (NULL == ch || scsi_device_get(ch->device)) {
spin_unlock(&ch_index_lock); spin_unlock(&ch_index_lock);
unlock_kernel(); mutex_unlock(&ch_mutex);
return -ENXIO; return -ENXIO;
} }
spin_unlock(&ch_index_lock); spin_unlock(&ch_index_lock);
file->private_data = ch; file->private_data = ch;
unlock_kernel(); mutex_unlock(&ch_mutex);
return 0; return 0;
} }

18
drivers/scsi/dpt_i2o.c
View File

@ -49,7 +49,6 @@ MODULE_DESCRIPTION("Adaptec I2O RAID Driver");
#include <linux/kernel.h> /* for printk */ #include <linux/kernel.h> /* for printk */
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/reboot.h> #include <linux/reboot.h>
#include <linux/smp_lock.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/dma-mapping.h> #include <linux/dma-mapping.h>
@ -76,6 +75,7 @@ MODULE_DESCRIPTION("Adaptec I2O RAID Driver");
* Needed for our management apps * Needed for our management apps
*============================================================================ *============================================================================
*/ */
static DEFINE_MUTEX(adpt_mutex);
static dpt_sig_S DPTI_sig = { static dpt_sig_S DPTI_sig = {
{'d', 'P', 't', 'S', 'i', 'G'}, SIG_VERSION, {'d', 'P', 't', 'S', 'i', 'G'}, SIG_VERSION,
#ifdef __i386__ #ifdef __i386__
@ -1732,12 +1732,12 @@ static int adpt_open(struct inode *inode, struct file *file)
int minor; int minor;
adpt_hba* pHba; adpt_hba* pHba;
lock_kernel(); mutex_lock(&adpt_mutex);
//TODO check for root access //TODO check for root access
// //
minor = iminor(inode); minor = iminor(inode);
if (minor >= hba_count) { if (minor >= hba_count) {
unlock_kernel(); mutex_unlock(&adpt_mutex);
return -ENXIO; return -ENXIO;
} }
mutex_lock(&adpt_configuration_lock); mutex_lock(&adpt_configuration_lock);
@ -1748,7 +1748,7 @@ static int adpt_open(struct inode *inode, struct file *file)
} }
if (pHba == NULL) { if (pHba == NULL) {
mutex_unlock(&adpt_configuration_lock); mutex_unlock(&adpt_configuration_lock);
unlock_kernel(); mutex_unlock(&adpt_mutex);
return -ENXIO; return -ENXIO;
} }
@ -1759,7 +1759,7 @@ static int adpt_open(struct inode *inode, struct file *file)
pHba->in_use = 1; pHba->in_use = 1;
mutex_unlock(&adpt_configuration_lock); mutex_unlock(&adpt_configuration_lock);
unlock_kernel(); mutex_unlock(&adpt_mutex);
return 0; return 0;
} }
@ -2160,9 +2160,9 @@ static long adpt_unlocked_ioctl(struct file *file, uint cmd, ulong arg)
inode = file->f_dentry->d_inode; inode = file->f_dentry->d_inode;
lock_kernel(); mutex_lock(&adpt_mutex);
ret = adpt_ioctl(inode, file, cmd, arg); ret = adpt_ioctl(inode, file, cmd, arg);
unlock_kernel(); mutex_unlock(&adpt_mutex);
return ret; return ret;
} }
@ -2176,7 +2176,7 @@ static long compat_adpt_ioctl(struct file *file,
inode = file->f_dentry->d_inode; inode = file->f_dentry->d_inode;
lock_kernel(); mutex_lock(&adpt_mutex);
switch(cmd) { switch(cmd) {
case DPT_SIGNATURE: case DPT_SIGNATURE:
@ -2194,7 +2194,7 @@ static long compat_adpt_ioctl(struct file *file,
ret = -ENOIOCTLCMD; ret = -ENOIOCTLCMD;
} }
unlock_kernel(); mutex_unlock(&adpt_mutex);
return ret; return ret;
} }

11
drivers/scsi/gdth.c
View File

@ -120,7 +120,7 @@
#include <linux/timer.h> #include <linux/timer.h>
#include <linux/dma-mapping.h> #include <linux/dma-mapping.h>
#include <linux/list.h> #include <linux/list.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/slab.h> #include <linux/slab.h>
#ifdef GDTH_RTC #ifdef GDTH_RTC
@ -140,6 +140,7 @@
#include <scsi/scsi_host.h> #include <scsi/scsi_host.h>
#include "gdth.h" #include "gdth.h"
static DEFINE_MUTEX(gdth_mutex);
static void gdth_delay(int milliseconds); static void gdth_delay(int milliseconds);
static void gdth_eval_mapping(u32 size, u32 *cyls, int *heads, int *secs); static void gdth_eval_mapping(u32 size, u32 *cyls, int *heads, int *secs);
static irqreturn_t gdth_interrupt(int irq, void *dev_id); static irqreturn_t gdth_interrupt(int irq, void *dev_id);
@ -4042,12 +4043,12 @@ static int gdth_open(struct inode *inode, struct file *filep)
{ {
gdth_ha_str *ha; gdth_ha_str *ha;
lock_kernel(); mutex_lock(&gdth_mutex);
list_for_each_entry(ha, &gdth_instances, list) { list_for_each_entry(ha, &gdth_instances, list) {
if (!ha->sdev) if (!ha->sdev)
ha->sdev = scsi_get_host_dev(ha->shost); ha->sdev = scsi_get_host_dev(ha->shost);
} }
unlock_kernel(); mutex_unlock(&gdth_mutex);
TRACE(("gdth_open()\n")); TRACE(("gdth_open()\n"));
return 0; return 0;
@ -4615,9 +4616,9 @@ static long gdth_unlocked_ioctl(struct file *file, unsigned int cmd,
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&gdth_mutex);
ret = gdth_ioctl(file, cmd, arg); ret = gdth_ioctl(file, cmd, arg);
unlock_kernel(); mutex_unlock(&gdth_mutex);
return ret; return ret;
} }

8
drivers/scsi/megaraid.c
View File

@ -46,7 +46,7 @@
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/dma-mapping.h> #include <linux/dma-mapping.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <scsi/scsicam.h> #include <scsi/scsicam.h>
@ -62,6 +62,7 @@ MODULE_DESCRIPTION ("LSI Logic MegaRAID legacy driver");
MODULE_LICENSE ("GPL"); MODULE_LICENSE ("GPL");
MODULE_VERSION(MEGARAID_MODULE_VERSION); MODULE_VERSION(MEGARAID_MODULE_VERSION);
static DEFINE_MUTEX(megadev_mutex);
static unsigned int max_cmd_per_lun = DEF_CMD_PER_LUN; static unsigned int max_cmd_per_lun = DEF_CMD_PER_LUN;
module_param(max_cmd_per_lun, uint, 0); module_param(max_cmd_per_lun, uint, 0);
MODULE_PARM_DESC(max_cmd_per_lun, "Maximum number of commands which can be issued to a single LUN (default=DEF_CMD_PER_LUN=63)"); MODULE_PARM_DESC(max_cmd_per_lun, "Maximum number of commands which can be issued to a single LUN (default=DEF_CMD_PER_LUN=63)");
@ -3282,7 +3283,6 @@ mega_init_scb(adapter_t *adapter)
static int static int
megadev_open (struct inode *inode, struct file *filep) megadev_open (struct inode *inode, struct file *filep)
{ {
cycle_kernel_lock();
/* /*
* Only allow superuser to access private ioctl interface * Only allow superuser to access private ioctl interface
*/ */
@ -3701,9 +3701,9 @@ megadev_unlocked_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&megadev_mutex);
ret = megadev_ioctl(filep, cmd, arg); ret = megadev_ioctl(filep, cmd, arg);
unlock_kernel(); mutex_unlock(&megadev_mutex);
return ret; return ret;
} }

8
drivers/scsi/megaraid/megaraid_mm.c
View File

@ -16,11 +16,12 @@
*/ */
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include "megaraid_mm.h" #include "megaraid_mm.h"
// Entry points for char node driver // Entry points for char node driver
static DEFINE_MUTEX(mraid_mm_mutex);
static int mraid_mm_open(struct inode *, struct file *); static int mraid_mm_open(struct inode *, struct file *);
static long mraid_mm_unlocked_ioctl(struct file *, uint, unsigned long); static long mraid_mm_unlocked_ioctl(struct file *, uint, unsigned long);
@ -98,7 +99,6 @@ mraid_mm_open(struct inode *inode, struct file *filep)
*/ */
if (!capable(CAP_SYS_ADMIN)) return (-EACCES); if (!capable(CAP_SYS_ADMIN)) return (-EACCES);
cycle_kernel_lock();
return 0; return 0;
} }
@ -224,9 +224,9 @@ mraid_mm_unlocked_ioctl(struct file *filep, unsigned int cmd,
int err; int err;
/* inconsistant: mraid_mm_compat_ioctl doesn't take the BKL */ /* inconsistant: mraid_mm_compat_ioctl doesn't take the BKL */
lock_kernel(); mutex_lock(&mraid_mm_mutex);
err = mraid_mm_ioctl(filep, cmd, arg); err = mraid_mm_ioctl(filep, cmd, arg);
unlock_kernel(); mutex_unlock(&mraid_mm_mutex);
return err; return err;
} }

2
drivers/scsi/megaraid/megaraid_sas.c
View File

@ -33,7 +33,6 @@
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/smp_lock.h>
#include <linux/uio.h> #include <linux/uio.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
@ -3557,7 +3556,6 @@ static void megasas_shutdown(struct pci_dev *pdev)
*/ */
static int megasas_mgmt_open(struct inode *inode, struct file *filep) static int megasas_mgmt_open(struct inode *inode, struct file *filep)
{ {
cycle_kernel_lock();
/* /*
* Allow only those users with admin rights * Allow only those users with admin rights
*/ */

11
drivers/scsi/mpt2sas/mpt2sas_ctl.c
View File

@ -51,7 +51,7 @@
#include <linux/types.h> #include <linux/types.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/compat.h> #include <linux/compat.h>
#include <linux/poll.h> #include <linux/poll.h>
@ -61,6 +61,7 @@
#include "mpt2sas_base.h" #include "mpt2sas_base.h"
#include "mpt2sas_ctl.h" #include "mpt2sas_ctl.h"
static DEFINE_MUTEX(_ctl_mutex);
static struct fasync_struct *async_queue; static struct fasync_struct *async_queue;
static DECLARE_WAIT_QUEUE_HEAD(ctl_poll_wait); static DECLARE_WAIT_QUEUE_HEAD(ctl_poll_wait);
@ -2238,9 +2239,9 @@ _ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{ {
long ret; long ret;
lock_kernel(); mutex_lock(&_ctl_mutex);
ret = _ctl_ioctl_main(file, cmd, (void __user *)arg); ret = _ctl_ioctl_main(file, cmd, (void __user *)arg);
unlock_kernel(); mutex_unlock(&_ctl_mutex);
return ret; return ret;
} }
@ -2309,12 +2310,12 @@ _ctl_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg)
{ {
long ret; long ret;
lock_kernel(); mutex_lock(&_ctl_mutex);
if (cmd == MPT2COMMAND32) if (cmd == MPT2COMMAND32)
ret = _ctl_compat_mpt_command(file, cmd, arg); ret = _ctl_compat_mpt_command(file, cmd, arg);
else else
ret = _ctl_ioctl_main(file, cmd, (void __user *)arg); ret = _ctl_ioctl_main(file, cmd, (void __user *)arg);
unlock_kernel(); mutex_unlock(&_ctl_mutex);
return ret; return ret;
} }
#endif #endif

15
drivers/scsi/osst.c
View File

@ -51,7 +51,7 @@ static const char * osst_version = "0.99.4";
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
#include <asm/dma.h> #include <asm/dma.h>
#include <asm/system.h> #include <asm/system.h>
@ -80,6 +80,7 @@ static const char * osst_version = "0.99.4";
#include "osst_options.h" #include "osst_options.h"
#include "osst_detect.h" #include "osst_detect.h"
static DEFINE_MUTEX(osst_int_mutex);
static int max_dev = 0; static int max_dev = 0;
static int write_threshold_kbs = 0; static int write_threshold_kbs = 0;
static int max_sg_segs = 0; static int max_sg_segs = 0;
@ -4807,9 +4808,9 @@ static int os_scsi_tape_open(struct inode * inode, struct file * filp)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&osst_int_mutex);
ret = __os_scsi_tape_open(inode, filp); ret = __os_scsi_tape_open(inode, filp);
unlock_kernel(); mutex_unlock(&osst_int_mutex);
return ret; return ret;
} }
@ -4943,9 +4944,9 @@ static long osst_ioctl(struct file * file,
char * name = tape_name(STp); char * name = tape_name(STp);
void __user * p = (void __user *)arg; void __user * p = (void __user *)arg;
lock_kernel(); mutex_lock(&osst_int_mutex);
if (mutex_lock_interruptible(&STp->lock)) { if (mutex_lock_interruptible(&STp->lock)) {
unlock_kernel(); mutex_unlock(&osst_int_mutex);
return -ERESTARTSYS; return -ERESTARTSYS;
} }
@ -5260,14 +5261,14 @@ static long osst_ioctl(struct file * file,
mutex_unlock(&STp->lock); mutex_unlock(&STp->lock);
retval = scsi_ioctl(STp->device, cmd_in, p); retval = scsi_ioctl(STp->device, cmd_in, p);
unlock_kernel(); mutex_unlock(&osst_int_mutex);
return retval; return retval;
out: out:
if (SRpnt) osst_release_request(SRpnt); if (SRpnt) osst_release_request(SRpnt);
mutex_unlock(&STp->lock); mutex_unlock(&STp->lock);
unlock_kernel(); mutex_unlock(&osst_int_mutex);
return retval; return retval;
} }

2
drivers/scsi/scsi_tgt_if.c
View File

@ -22,7 +22,6 @@
#include <linux/miscdevice.h> #include <linux/miscdevice.h>
#include <linux/gfp.h> #include <linux/gfp.h>
#include <linux/file.h> #include <linux/file.h>
#include <linux/smp_lock.h>
#include <net/tcp.h> #include <net/tcp.h>
#include <scsi/scsi.h> #include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h> #include <scsi/scsi_cmnd.h>
@ -323,7 +322,6 @@ static int tgt_open(struct inode *inode, struct file *file)
{ {
tx_ring.tr_idx = rx_ring.tr_idx = 0; tx_ring.tr_idx = rx_ring.tr_idx = 0;
cycle_kernel_lock();
return 0; return 0;
} }

12
drivers/scsi/sg.c
View File

@ -49,7 +49,7 @@ static int sg_version_num = 30534; /* 2 digits for each component */
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/blktrace_api.h> #include <linux/blktrace_api.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include "scsi.h" #include "scsi.h"
#include <scsi/scsi_dbg.h> #include <scsi/scsi_dbg.h>
@ -103,6 +103,8 @@ static int scatter_elem_sz_prev = SG_SCATTER_SZ;
static int sg_add(struct device *, struct class_interface *); static int sg_add(struct device *, struct class_interface *);
static void sg_remove(struct device *, struct class_interface *); static void sg_remove(struct device *, struct class_interface *);
static DEFINE_MUTEX(sg_mutex);
static DEFINE_IDR(sg_index_idr); static DEFINE_IDR(sg_index_idr);
static DEFINE_RWLOCK(sg_index_lock); /* Also used to lock static DEFINE_RWLOCK(sg_index_lock); /* Also used to lock
file descriptor list for device */ file descriptor list for device */
@ -229,7 +231,7 @@ sg_open(struct inode *inode, struct file *filp)
int res; int res;
int retval; int retval;
lock_kernel(); mutex_lock(&sg_mutex);
nonseekable_open(inode, filp); nonseekable_open(inode, filp);
SCSI_LOG_TIMEOUT(3, printk("sg_open: dev=%d, flags=0x%x\n", dev, flags)); SCSI_LOG_TIMEOUT(3, printk("sg_open: dev=%d, flags=0x%x\n", dev, flags));
sdp = sg_get_dev(dev); sdp = sg_get_dev(dev);
@ -314,7 +316,7 @@ sdp_put:
sg_put: sg_put:
if (sdp) if (sdp)
sg_put_dev(sdp); sg_put_dev(sdp);
unlock_kernel(); mutex_unlock(&sg_mutex);
return retval; return retval;
} }
@ -1092,9 +1094,9 @@ sg_unlocked_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&sg_mutex);
ret = sg_ioctl(filp, cmd_in, arg); ret = sg_ioctl(filp, cmd_in, arg);
unlock_kernel(); mutex_unlock(&sg_mutex);
return ret; return ret;
} }

14
drivers/scsi/sr.c
View File

@ -44,7 +44,6 @@
#include <linux/init.h> #include <linux/init.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/smp_lock.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
@ -76,6 +75,7 @@ MODULE_ALIAS_SCSI_DEVICE(TYPE_WORM);
CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_DVD_RAM|CDC_GENERIC_PACKET| \ CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_DVD_RAM|CDC_GENERIC_PACKET| \
CDC_MRW|CDC_MRW_W|CDC_RAM) CDC_MRW|CDC_MRW_W|CDC_RAM)
static DEFINE_MUTEX(sr_mutex);
static int sr_probe(struct device *); static int sr_probe(struct device *);
static int sr_remove(struct device *); static int sr_remove(struct device *);
static int sr_done(struct scsi_cmnd *); static int sr_done(struct scsi_cmnd *);
@ -470,24 +470,24 @@ static int sr_block_open(struct block_device *bdev, fmode_t mode)
struct scsi_cd *cd; struct scsi_cd *cd;
int ret = -ENXIO; int ret = -ENXIO;
lock_kernel(); mutex_lock(&sr_mutex);
cd = scsi_cd_get(bdev->bd_disk); cd = scsi_cd_get(bdev->bd_disk);
if (cd) { if (cd) {
ret = cdrom_open(&cd->cdi, bdev, mode); ret = cdrom_open(&cd->cdi, bdev, mode);
if (ret) if (ret)
scsi_cd_put(cd); scsi_cd_put(cd);
} }
unlock_kernel(); mutex_unlock(&sr_mutex);
return ret; return ret;
} }
static int sr_block_release(struct gendisk *disk, fmode_t mode) static int sr_block_release(struct gendisk *disk, fmode_t mode)
{ {
struct scsi_cd *cd = scsi_cd(disk); struct scsi_cd *cd = scsi_cd(disk);
lock_kernel(); mutex_lock(&sr_mutex);
cdrom_release(&cd->cdi, mode); cdrom_release(&cd->cdi, mode);
scsi_cd_put(cd); scsi_cd_put(cd);
unlock_kernel(); mutex_unlock(&sr_mutex);
return 0; return 0;
} }
@ -499,7 +499,7 @@ static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
void __user *argp = (void __user *)arg; void __user *argp = (void __user *)arg;
int ret; int ret;
lock_kernel(); mutex_lock(&sr_mutex);
/* /*
* Send SCSI addressing ioctls directly to mid level, send other * Send SCSI addressing ioctls directly to mid level, send other
@ -529,7 +529,7 @@ static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
ret = scsi_ioctl(sdev, cmd, argp); ret = scsi_ioctl(sdev, cmd, argp);
out: out:
unlock_kernel(); mutex_unlock(&sr_mutex);
return ret; return ret;
} }

12
drivers/scsi/st.c
View File

@ -39,7 +39,6 @@ static const char *verstr = "20081215";
#include <linux/cdev.h> #include <linux/cdev.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/mutex.h> #include <linux/mutex.h>
#include <linux/smp_lock.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
#include <asm/dma.h> #include <asm/dma.h>
@ -76,6 +75,7 @@ static const char *verstr = "20081215";
#include "st_options.h" #include "st_options.h"
#include "st.h" #include "st.h"
static DEFINE_MUTEX(st_mutex);
static int buffer_kbs; static int buffer_kbs;
static int max_sg_segs; static int max_sg_segs;
static int try_direct_io = TRY_DIRECT_IO; static int try_direct_io = TRY_DIRECT_IO;
@ -1180,7 +1180,7 @@ static int st_open(struct inode *inode, struct file *filp)
int dev = TAPE_NR(inode); int dev = TAPE_NR(inode);
char *name; char *name;
lock_kernel(); mutex_lock(&st_mutex);
/* /*
* We really want to do nonseekable_open(inode, filp); here, but some * We really want to do nonseekable_open(inode, filp); here, but some
* versions of tar incorrectly call lseek on tapes and bail out if that * versions of tar incorrectly call lseek on tapes and bail out if that
@ -1189,7 +1189,7 @@ static int st_open(struct inode *inode, struct file *filp)
filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE); filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
if (!(STp = scsi_tape_get(dev))) { if (!(STp = scsi_tape_get(dev))) {
unlock_kernel(); mutex_unlock(&st_mutex);
return -ENXIO; return -ENXIO;
} }
@ -1200,7 +1200,7 @@ static int st_open(struct inode *inode, struct file *filp)
if (STp->in_use) { if (STp->in_use) {
write_unlock(&st_dev_arr_lock); write_unlock(&st_dev_arr_lock);
scsi_tape_put(STp); scsi_tape_put(STp);
unlock_kernel(); mutex_unlock(&st_mutex);
DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); ) DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
return (-EBUSY); return (-EBUSY);
} }
@ -1249,14 +1249,14 @@ static int st_open(struct inode *inode, struct file *filp)
retval = (-EIO); retval = (-EIO);
goto err_out; goto err_out;
} }
unlock_kernel(); mutex_unlock(&st_mutex);
return 0; return 0;
err_out: err_out:
normalize_buffer(STp->buffer); normalize_buffer(STp->buffer);
STp->in_use = 0; STp->in_use = 0;
scsi_tape_put(STp); scsi_tape_put(STp);
unlock_kernel(); mutex_unlock(&st_mutex);
return retval; return retval;
} }

11
drivers/staging/hv/blkvsc_drv.c
View File

@ -25,7 +25,7 @@
#include <linux/major.h> #include <linux/major.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/hdreg.h> #include <linux/hdreg.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <scsi/scsi.h> #include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h> #include <scsi/scsi_cmnd.h>
@ -124,6 +124,7 @@ struct blkvsc_driver_context {
}; };
/* Static decl */ /* Static decl */
static DEFINE_MUTEX(blkvsc_mutex);
static int blkvsc_probe(struct device *dev); static int blkvsc_probe(struct device *dev);
static int blkvsc_remove(struct device *device); static int blkvsc_remove(struct device *device);
static void blkvsc_shutdown(struct device *device); static void blkvsc_shutdown(struct device *device);
@ -1309,7 +1310,7 @@ static int blkvsc_open(struct block_device *bdev, fmode_t mode)
DPRINT_DBG(BLKVSC_DRV, "- users %d disk %s\n", blkdev->users, DPRINT_DBG(BLKVSC_DRV, "- users %d disk %s\n", blkdev->users,
blkdev->gd->disk_name); blkdev->gd->disk_name);
lock_kernel(); mutex_lock(&blkvsc_mutex);
spin_lock(&blkdev->lock); spin_lock(&blkdev->lock);
if (!blkdev->users && blkdev->device_type == DVD_TYPE) { if (!blkdev->users && blkdev->device_type == DVD_TYPE) {
@ -1321,7 +1322,7 @@ static int blkvsc_open(struct block_device *bdev, fmode_t mode)
blkdev->users++; blkdev->users++;
spin_unlock(&blkdev->lock); spin_unlock(&blkdev->lock);
unlock_kernel(); mutex_unlock(&blkvsc_mutex);
return 0; return 0;
} }
@ -1332,7 +1333,7 @@ static int blkvsc_release(struct gendisk *disk, fmode_t mode)
DPRINT_DBG(BLKVSC_DRV, "- users %d disk %s\n", blkdev->users, DPRINT_DBG(BLKVSC_DRV, "- users %d disk %s\n", blkdev->users,
blkdev->gd->disk_name); blkdev->gd->disk_name);
lock_kernel(); mutex_lock(&blkvsc_mutex);
spin_lock(&blkdev->lock); spin_lock(&blkdev->lock);
if (blkdev->users == 1) { if (blkdev->users == 1) {
spin_unlock(&blkdev->lock); spin_unlock(&blkdev->lock);
@ -1343,7 +1344,7 @@ static int blkvsc_release(struct gendisk *disk, fmode_t mode)
blkdev->users--; blkdev->users--;
spin_unlock(&blkdev->lock); spin_unlock(&blkdev->lock);
unlock_kernel(); mutex_unlock(&blkvsc_mutex);
return 0; return 0;
} }

7
drivers/staging/spectra/ffsport.c
View File

@ -27,7 +27,6 @@
#include <linux/kthread.h> #include <linux/kthread.h>
#include <linux/log2.h> #include <linux/log2.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/smp_lock.h>
#include <linux/slab.h> #include <linux/slab.h>
/**** Helper functions used for Div, Remainder operation on u64 ****/ /**** Helper functions used for Div, Remainder operation on u64 ****/
@ -590,14 +589,16 @@ int GLOB_SBD_ioctl(struct block_device *bdev, fmode_t mode,
return -ENOTTY; return -ENOTTY;
} }
static DEFINE_MUTEX(ffsport_mutex);
int GLOB_SBD_unlocked_ioctl(struct block_device *bdev, fmode_t mode, int GLOB_SBD_unlocked_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
int ret; int ret;
lock_kernel(); mutex_lock(&ffsport_mutex);
ret = GLOB_SBD_ioctl(bdev, mode, cmd, arg); ret = GLOB_SBD_ioctl(bdev, mode, cmd, arg);
unlock_kernel(); mutex_unlock(&ffsport_mutex);
return ret; return ret;
} }

7
drivers/telephony/ixj.c
View File

@ -257,7 +257,7 @@
#include <linux/fs.h> /* everything... */ #include <linux/fs.h> /* everything... */
#include <linux/errno.h> /* error codes */ #include <linux/errno.h> /* error codes */
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/ioport.h> #include <linux/ioport.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
@ -277,6 +277,7 @@
#define TYPE(inode) (iminor(inode) >> 4) #define TYPE(inode) (iminor(inode) >> 4)
#define NUM(inode) (iminor(inode) & 0xf) #define NUM(inode) (iminor(inode) & 0xf)
static DEFINE_MUTEX(ixj_mutex);
static int ixjdebug; static int ixjdebug;
static int hertz = HZ; static int hertz = HZ;
static int samplerate = 100; static int samplerate = 100;
@ -6655,9 +6656,9 @@ static long do_ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long ar
static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg) static long ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg)
{ {
long ret; long ret;
lock_kernel(); mutex_lock(&ixj_mutex);
ret = do_ixj_ioctl(file_p, cmd, arg); ret = do_ixj_ioctl(file_p, cmd, arg);
unlock_kernel(); mutex_unlock(&ixj_mutex);
return ret; return ret;
} }

15
drivers/watchdog/cpwd.c
View File

@ -25,7 +25,7 @@
#include <linux/ioport.h> #include <linux/ioport.h>
#include <linux/timer.h> #include <linux/timer.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp_lock.h> #include <linux/mutex.h>
#include <linux/io.h> #include <linux/io.h>
#include <linux/of.h> #include <linux/of.h>
#include <linux/of_device.h> #include <linux/of_device.h>
@ -89,6 +89,7 @@ struct cpwd {
} devs[WD_NUMDEVS]; } devs[WD_NUMDEVS];
}; };
static DEFINE_MUTEX(cpwd_mutex);
static struct cpwd *cpwd_device; static struct cpwd *cpwd_device;
/* Sun uses Altera PLD EPF8820ATC144-4 /* Sun uses Altera PLD EPF8820ATC144-4
@ -368,7 +369,7 @@ static int cpwd_open(struct inode *inode, struct file *f)
{ {
struct cpwd *p = cpwd_device; struct cpwd *p = cpwd_device;
lock_kernel(); mutex_lock(&cpwd_mutex);
switch (iminor(inode)) { switch (iminor(inode)) {
case WD0_MINOR: case WD0_MINOR:
case WD1_MINOR: case WD1_MINOR:
@ -376,7 +377,7 @@ static int cpwd_open(struct inode *inode, struct file *f)
break; break;
default: default:
unlock_kernel(); mutex_unlock(&cpwd_mutex);
return -ENODEV; return -ENODEV;
} }
@ -386,13 +387,13 @@ static int cpwd_open(struct inode *inode, struct file *f)
IRQF_SHARED, DRIVER_NAME, p)) { IRQF_SHARED, DRIVER_NAME, p)) {
printk(KERN_ERR PFX "Cannot register IRQ %d\n", printk(KERN_ERR PFX "Cannot register IRQ %d\n",
p->irq); p->irq);
unlock_kernel(); mutex_unlock(&cpwd_mutex);
return -EBUSY; return -EBUSY;
} }
p->initialized = true; p->initialized = true;
} }
unlock_kernel(); mutex_unlock(&cpwd_mutex);
return nonseekable_open(inode, f); return nonseekable_open(inode, f);
} }
@ -482,9 +483,9 @@ static long cpwd_compat_ioctl(struct file *file, unsigned int cmd,
case WIOCSTART: case WIOCSTART:
case WIOCSTOP: case WIOCSTOP:
case WIOCGSTAT: case WIOCGSTAT:
lock_kernel(); mutex_lock(&cpwd_mutex);
rval = cpwd_ioctl(file, cmd, arg); rval = cpwd_ioctl(file, cmd, arg);
unlock_kernel(); mutex_unlock(&cpwd_mutex);
break; break;
/* everything else is handled by the generic compat layer */ /* everything else is handled by the generic compat layer */