28 files changed, 252 insertions, 74 deletions

diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index 832798aa14f6..0fa26359304c 100644
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -60,6 +60,7 @@
 #include <linux/hdreg.h>
 #include <linux/delay.h>
 #include <linux/init.h>
+#include <linux/smp_lock.h>
 #include <linux/amifdreg.h>
 #include <linux/amifd.h>
 #include <linux/buffer_head.h>
@@ -1423,7 +1424,7 @@ static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
         return 0;
 }
 
-static int fd_ioctl(struct block_device *bdev, fmode_t mode,
+static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode,
                     unsigned int cmd, unsigned long param)
 {
         struct amiga_floppy_struct *p = bdev->bd_disk->private_data;
@@ -1500,6 +1501,18 @@ static int fd_ioctl(struct block_device *bdev, fmode_t mode,
         return 0;
 }
 
+static int fd_ioctl(struct block_device *bdev, fmode_t mode,
+                             unsigned int cmd, unsigned long param)
+{
+        int ret;
+
+        lock_kernel();
+        ret = fd_locked_ioctl(bdev, mode, cmd, param);
+        unlock_kernel();
+
+        return ret;
+}
+
 static void fd_probe(int dev)
 {
         unsigned long code;
@@ -1638,7 +1651,7 @@ static const struct block_device_operations floppy_fops = {
         .owner          = THIS_MODULE,
         .open           = floppy_open,
         .release        = floppy_release,
-        .locked_ioctl   = fd_ioctl,
+        .ioctl          = fd_ioctl,
         .getgeo         = fd_getgeo,
         .media_changed  = amiga_floppy_change,
 };
diff --git a/drivers/block/ataflop.c b/drivers/block/ataflop.c
index e35cf59cbfde..1bb8bfcfdbd9 100644
--- a/drivers/block/ataflop.c
+++ b/drivers/block/ataflop.c
@@ -67,6 +67,7 @@
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/blkdev.h>
+#include <linux/smp_lock.h>
 
 #include <asm/atafd.h>
 #include <asm/atafdreg.h>
@@ -359,7 +360,7 @@ static void finish_fdc( void );
 static void finish_fdc_done( int dummy );
 static void setup_req_params( int drive );
 static void redo_fd_request( void);
-static int fd_ioctl(struct block_device *bdev, fmode_t mode, unsigned int
+static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode, unsigned int
                      cmd, unsigned long param);
 static void fd_probe( int drive );
 static int fd_test_drive_present( int drive );
@@ -1480,7 +1481,7 @@ void do_fd_request(struct request_queue * q)
         atari_enable_irq( IRQ_MFP_FDC );
 }
 
-static int fd_ioctl(struct block_device *bdev, fmode_t mode,
+static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode,
                     unsigned int cmd, unsigned long param)
 {
         struct gendisk *disk = bdev->bd_disk;
@@ -1665,6 +1666,17 @@ static int fd_ioctl(struct block_device *bdev, fmode_t mode,
         }
 }
 
+static int fd_ioctl(struct block_device *bdev, fmode_t mode,
+                             unsigned int cmd, unsigned long arg)
+{
+        int ret;
+
+        lock_kernel();
+        ret = fd_locked_ioctl(bdev, mode, cmd, arg);
+        unlock_kernel();
+
+        return ret;
+}
 
 /* Initialize the 'unit' variable for drive 'drive' */
 
@@ -1855,7 +1867,7 @@ static const struct block_device_operations floppy_fops = {
         .owner          = THIS_MODULE,
         .open           = floppy_open,
         .release        = floppy_release,
-        .locked_ioctl   = fd_ioctl,
+        .ioctl          = fd_ioctl,
         .media_changed  = check_floppy_change,
         .revalidate_disk= floppy_revalidate,
 };
diff --git a/drivers/block/brd.c b/drivers/block/brd.c
index 1d2c18620f9a..1c7f63792ff8 100644
--- a/drivers/block/brd.c
+++ b/drivers/block/brd.c
@@ -15,6 +15,7 @@
 #include <linux/blkdev.h>
 #include <linux/bio.h>
 #include <linux/highmem.h>
+#include <linux/smp_lock.h>
 #include <linux/radix-tree.h>
 #include <linux/buffer_head.h> /* invalidate_bh_lrus() */
 #include <linux/slab.h>
@@ -401,6 +402,7 @@ static int brd_ioctl(struct block_device *bdev, fmode_t mode,
          * ram device BLKFLSBUF has special semantics, we want to actually
          * release and destroy the ramdisk data.
          */
+        lock_kernel();
         mutex_lock(&bdev->bd_mutex);
         error = -EBUSY;
         if (bdev->bd_openers <= 1) {
@@ -417,13 +419,14 @@ static int brd_ioctl(struct block_device *bdev, fmode_t mode,
                 error = 0;
         }
         mutex_unlock(&bdev->bd_mutex);
+        unlock_kernel();
 
         return error;
 }
 
 static const struct block_device_operations brd_fops = {
         .owner =                THIS_MODULE,
-        .locked_ioctl =         brd_ioctl,
+        .ioctl =                brd_ioctl,
 #ifdef CONFIG_BLK_DEV_XIP
         .direct_access =        brd_direct_access,
 #endif
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 11b377762b8e..a6c0494dd054 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -179,6 +179,8 @@ static irqreturn_t do_cciss_intx(int irq, void *dev_id);
 static irqreturn_t do_cciss_msix_intr(int irq, void *dev_id);
 static int cciss_open(struct block_device *bdev, fmode_t mode);
 static int cciss_release(struct gendisk *disk, fmode_t mode);
+static int do_ioctl(struct block_device *bdev, fmode_t mode,
+                    unsigned int cmd, unsigned long arg);
 static int cciss_ioctl(struct block_device *bdev, fmode_t mode,
                        unsigned int cmd, unsigned long arg);
 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
@@ -237,7 +239,7 @@ static const struct block_device_operations cciss_fops = {
         .owner = THIS_MODULE,
         .open = cciss_open,
         .release = cciss_release,
-        .locked_ioctl = cciss_ioctl,
+        .ioctl = do_ioctl,
         .getgeo = cciss_getgeo,
 #ifdef CONFIG_COMPAT
         .compat_ioctl = cciss_compat_ioctl,
@@ -1057,8 +1059,6 @@ static int cciss_release(struct gendisk *disk, fmode_t mode)
         return 0;
 }
 
-#ifdef CONFIG_COMPAT
-
 static int do_ioctl(struct block_device *bdev, fmode_t mode,
                     unsigned cmd, unsigned long arg)
 {
@@ -1069,6 +1069,8 @@ static int do_ioctl(struct block_device *bdev, fmode_t mode,
         return ret;
 }
 
+#ifdef CONFIG_COMPAT
+
 static int cciss_ioctl32_passthru(struct block_device *bdev, fmode_t mode,
                                   unsigned cmd, unsigned long arg);
 static int cciss_ioctl32_big_passthru(struct block_device *bdev, fmode_t mode,
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index abb4ec6690fc..c459aeea3c0c 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -35,6 +35,7 @@
 #include <linux/seq_file.h>
 #include <linux/init.h>
 #include <linux/hdreg.h>
+#include <linux/smp_lock.h>
 #include <linux/spinlock.h>
 #include <linux/blkdev.h>
 #include <linux/genhd.h>
@@ -197,7 +198,7 @@ static const struct block_device_operations ida_fops  = {
         .owner          = THIS_MODULE,
         .open           = ida_open,
         .release        = ida_release,
-        .locked_ioctl   = ida_ioctl,
+        .ioctl          = ida_ioctl,
         .getgeo         = ida_getgeo,
         .revalidate_disk= ida_revalidate,
 };
@@ -1128,7 +1129,7 @@ static int ida_getgeo(struct block_device *bdev, struct hd_geometry *geo)
  *  ida_ioctl does some miscellaneous stuff like reporting drive geometry,
  *  setting readahead and submitting commands from userspace to the controller.
  */
-static int ida_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
+static int ida_locked_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
 {
         drv_info_t *drv = get_drv(bdev->bd_disk);
         ctlr_info_t *host = get_host(bdev->bd_disk);
@@ -1192,6 +1193,19 @@ out_passthru:
         }
                 
 }
+
+static int ida_ioctl(struct block_device *bdev, fmode_t mode,
+                             unsigned int cmd, unsigned long param)
+{
+        int ret;
+
+        lock_kernel();
+        ret = ida_locked_ioctl(bdev, mode, cmd, param);
+        unlock_kernel();
+
+        return ret;
+}
+
 /*
  * ida_ctlr_ioctl is for passing commands to the controller from userspace.
  * The command block (io) has already been copied to kernel space for us,
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 82c30f9f81ca..40419b066aa9 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -178,6 +178,7 @@ static int print_unex = 1;
 #include <linux/slab.h>
 #include <linux/mm.h>
 #include <linux/bio.h>
+#include <linux/smp_lock.h>
 #include <linux/string.h>
 #include <linux/jiffies.h>
 #include <linux/fcntl.h>
@@ -3371,7 +3372,7 @@ static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
         return 0;
 }
 
-static int fd_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
+static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
                     unsigned long param)
 {
         int drive = (long)bdev->bd_disk->private_data;
@@ -3547,6 +3548,18 @@ static int fd_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
         return 0;
 }
 
+static int fd_ioctl(struct block_device *bdev, fmode_t mode,
+                             unsigned int cmd, unsigned long param)
+{
+        int ret;
+
+        lock_kernel();
+        ret = fd_locked_ioctl(bdev, mode, cmd, param);
+        unlock_kernel();
+
+        return ret;
+}
+
 static void __init config_types(void)
 {
         bool has_drive = false;
@@ -3848,7 +3861,7 @@ static const struct block_device_operations floppy_fops = {
         .owner                  = THIS_MODULE,
         .open                   = floppy_open,
         .release                = floppy_release,
-        .locked_ioctl           = fd_ioctl,
+        .ioctl                  = fd_ioctl,
         .getgeo                 = fd_getgeo,
         .media_changed          = check_floppy_change,
         .revalidate_disk        = floppy_revalidate,
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 2e74e7d475ca..6751789fb379 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -24,6 +24,7 @@
 #include <linux/errno.h>
 #include <linux/file.h>
 #include <linux/ioctl.h>
+#include <linux/smp_lock.h>
 #include <linux/compiler.h>
 #include <linux/err.h>
 #include <linux/kernel.h>
@@ -716,9 +717,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",
                         lo->disk->disk_name, ioctl_cmd_to_ascii(cmd), cmd, arg);
 
+        lock_kernel();
         mutex_lock(&lo->tx_lock);
         error = __nbd_ioctl(bdev, lo, cmd, arg);
         mutex_unlock(&lo->tx_lock);
+        unlock_kernel();
 
         return error;
 }
@@ -726,7 +729,7 @@ static int nbd_ioctl(struct block_device *bdev, fmode_t mode,
 static const struct block_device_operations nbd_fops =
 {
         .owner =        THIS_MODULE,
-        .locked_ioctl = nbd_ioctl,
+        .ioctl =        nbd_ioctl,
 };
 
 /*
diff --git a/drivers/block/paride/pcd.c b/drivers/block/paride/pcd.c
index 71acf4e53356..daba7a62a663 100644
--- a/drivers/block/paride/pcd.c
+++ b/drivers/block/paride/pcd.c
@@ -138,6 +138,7 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_DLY};
 #include <linux/cdrom.h>
 #include <linux/spinlock.h>
 #include <linux/blkdev.h>
+#include <linux/smp_lock.h>
 #include <asm/uaccess.h>
 
 static DEFINE_SPINLOCK(pcd_lock);
@@ -238,7 +239,13 @@ static int pcd_block_ioctl(struct block_device *bdev, fmode_t mode,
                                 unsigned cmd, unsigned long arg)
 {
         struct pcd_unit *cd = bdev->bd_disk->private_data;
-        return cdrom_ioctl(&cd->info, bdev, mode, cmd, arg);
+        int ret;
+
+        lock_kernel();
+        ret = cdrom_ioctl(&cd->info, bdev, mode, cmd, arg);
+        unlock_kernel();
+
+        return ret;
 }
 
 static int pcd_block_media_changed(struct gendisk *disk)
@@ -251,7 +258,7 @@ static const struct block_device_operations pcd_bdops = {
         .owner          = THIS_MODULE,
         .open           = pcd_block_open,
         .release        = pcd_block_release,
-        .locked_ioctl   = pcd_block_ioctl,
+        .ioctl          = pcd_block_ioctl,
         .media_changed  = pcd_block_media_changed,
 };
 
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 4e8b9bff3abe..c4d6ed9846ca 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -153,6 +153,7 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_GEO, D_SBY, D_DLY, D_SLV};
 #include <linux/blkdev.h>
 #include <linux/blkpg.h>
 #include <linux/kernel.h>
+#include <linux/smp_lock.h>
 #include <asm/uaccess.h>
 #include <linux/workqueue.h>
 
@@ -768,8 +769,10 @@ static int pd_ioctl(struct block_device *bdev, fmode_t mode,
 
         switch (cmd) {
         case CDROMEJECT:
+                lock_kernel();
                 if (disk->access == 1)
                         pd_special_command(disk, pd_eject);
+                unlock_kernel();
                 return 0;
         default:
                 return -EINVAL;
@@ -812,7 +815,7 @@ static const struct block_device_operations pd_fops = {
         .owner          = THIS_MODULE,
         .open           = pd_open,
         .release        = pd_release,
-        .locked_ioctl   = pd_ioctl,
+        .ioctl          = pd_ioctl,
         .getgeo         = pd_getgeo,
         .media_changed  = pd_check_media,
         .revalidate_disk= pd_revalidate
diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index c059aab3006b..38b4d566b816 100644
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -152,6 +152,7 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_LUN, D_DLY};
 #include <linux/spinlock.h>
 #include <linux/blkdev.h>
 #include <linux/blkpg.h>
+#include <linux/smp_lock.h>
 #include <asm/uaccess.h>
 
 static DEFINE_SPINLOCK(pf_spin_lock);
@@ -266,7 +267,7 @@ static const struct block_device_operations pf_fops = {
         .owner          = THIS_MODULE,
         .open           = pf_open,
         .release        = pf_release,
-        .locked_ioctl   = pf_ioctl,
+        .ioctl          = pf_ioctl,
         .getgeo         = pf_getgeo,
         .media_changed  = pf_check_media,
 };
@@ -342,7 +343,10 @@ static int pf_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, u
 
         if (pf->access != 1)
                 return -EBUSY;
+        lock_kernel();
         pf_eject(pf);
+        unlock_kernel();
+
         return 0;
 }
 
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 9f3e4454274b..40f1e31f42c4 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -57,6 +57,7 @@
 #include <linux/seq_file.h>
 #include <linux/miscdevice.h>
 #include <linux/freezer.h>
+#include <linux/smp_lock.h>
 #include <linux/mutex.h>
 #include <linux/slab.h>
 #include <scsi/scsi_cmnd.h>
@@ -2762,10 +2763,12 @@ out_mem:
 static int pkt_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
 {
         struct pktcdvd_device *pd = bdev->bd_disk->private_data;
+        int ret;
 
         VPRINTK("pkt_ioctl: cmd %x, dev %d:%d\n", cmd,
                 MAJOR(bdev->bd_dev), MINOR(bdev->bd_dev));
 
+        lock_kernel();
         switch (cmd) {
         case CDROMEJECT:
                 /*
@@ -2783,14 +2786,16 @@ static int pkt_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
         case CDROM_LAST_WRITTEN:
         case CDROM_SEND_PACKET:
         case SCSI_IOCTL_SEND_COMMAND:
-                return __blkdev_driver_ioctl(pd->bdev, mode, cmd, arg);
+                ret = __blkdev_driver_ioctl(pd->bdev, mode, cmd, arg);
+                break;
 
         default:
                 VPRINTK(DRIVER_NAME": Unknown ioctl for %s (%x)\n", pd->name, cmd);
-                return -ENOTTY;
+                ret = -ENOTTY;
         }
+        unlock_kernel();
 
-        return 0;
+        return ret;
 }
 
 static int pkt_media_changed(struct gendisk *disk)
@@ -2812,7 +2817,7 @@ static const struct block_device_operations pktcdvd_ops = {
         .owner =                THIS_MODULE,
         .open =                 pkt_open,
         .release =              pkt_close,
-        .locked_ioctl =         pkt_ioctl,
+        .ioctl =                pkt_ioctl,
         .media_changed =        pkt_media_changed,
 };
 
diff --git a/drivers/block/swim.c b/drivers/block/swim.c
index e463657569ff..f04f74e3758f 100644
--- a/drivers/block/swim.c
+++ b/drivers/block/swim.c
@@ -20,6 +20,7 @@
 #include <linux/fd.h>
 #include <linux/slab.h>
 #include <linux/blkdev.h>
+#include <linux/smp_lock.h>
 #include <linux/hdreg.h>
 #include <linux/kernel.h>
 #include <linux/delay.h>
@@ -690,7 +691,9 @@ static int floppy_ioctl(struct block_device *bdev, fmode_t mode,
         case FDEJECT:
                 if (fs->ref_count != 1)
                         return -EBUSY;
+                lock_kernel();
                 err = floppy_eject(fs);
+                unlock_kernel();
                 return err;
 
         case FDGETPRM:
@@ -753,7 +756,7 @@ static const struct block_device_operations floppy_fops = {
         .owner           = THIS_MODULE,
         .open            = floppy_open,
         .release         = floppy_release,
-        .locked_ioctl    = floppy_ioctl,
+        .ioctl           = floppy_ioctl,
         .getgeo          = floppy_getgeo,
         .media_changed   = floppy_check_change,
         .revalidate_disk = floppy_revalidate,
diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index ed6fb91123ab..f3657b2a5386 100644
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -25,6 +25,7 @@
 #include <linux/ioctl.h>
 #include <linux/blkdev.h>
 #include <linux/interrupt.h>
+#include <linux/smp_lock.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
 #include <asm/io.h>
@@ -839,7 +840,7 @@ static int fd_eject(struct floppy_state *fs)
 static struct floppy_struct floppy_type =
         { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,NULL };    /*  7 1.44MB 3.5"   */
 
-static int floppy_ioctl(struct block_device *bdev, fmode_t mode,
+static int floppy_locked_ioctl(struct block_device *bdev, fmode_t mode,
                         unsigned int cmd, unsigned long param)
 {
         struct floppy_state *fs = bdev->bd_disk->private_data;
@@ -867,6 +868,18 @@ static int floppy_ioctl(struct block_device *bdev, fmode_t mode,
         return -ENOTTY;
 }
 
+static int floppy_ioctl(struct block_device *bdev, fmode_t mode,
+                                 unsigned int cmd, unsigned long param)
+{
+        int ret;
+
+        lock_kernel();
+        ret = floppy_locked_ioctl(bdev, mode, cmd, param);
+        unlock_kernel();
+
+        return ret;
+}
+
 static int floppy_open(struct block_device *bdev, fmode_t mode)
 {
         struct floppy_state *fs = bdev->bd_disk->private_data;
@@ -997,7 +1010,7 @@ static int floppy_revalidate(struct gendisk *disk)
 static const struct block_device_operations floppy_fops = {
         .open           = floppy_open,
         .release        = floppy_release,
-        .locked_ioctl   = floppy_ioctl,
+        .ioctl          = floppy_ioctl,
         .media_changed  = floppy_check_change,
         .revalidate_disk= floppy_revalidate,
 };
diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index aaf27fb4efd6..102ed52d0e0f 100644
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -28,6 +28,7 @@
 #include <linux/timer.h>
 #include <linux/scatterlist.h>
 #include <linux/slab.h>
+#include <linux/smp_lock.h>
 #include <scsi/scsi.h>
 
 #define DRV_NAME "ub"
@@ -1729,8 +1730,13 @@ static int ub_bd_ioctl(struct block_device *bdev, fmode_t mode,
 {
         struct gendisk *disk = bdev->bd_disk;
         void __user *usermem = (void __user *) arg;
+        int ret;
+
+        lock_kernel();
+        ret = scsi_cmd_ioctl(disk->queue, disk, mode, cmd, usermem);
+        unlock_kernel();
 
-        return scsi_cmd_ioctl(disk->queue, disk, mode, cmd, usermem);
+        return ret;
 }
 
 /*
@@ -1794,7 +1800,7 @@ static const struct block_device_operations ub_bd_fops = {
         .owner          = THIS_MODULE,
         .open           = ub_bd_open,
         .release        = ub_bd_release,
-        .locked_ioctl   = ub_bd_ioctl,
+        .ioctl          = ub_bd_ioctl,
         .media_changed  = ub_bd_media_changed,
         .revalidate_disk = ub_bd_revalidate,
 };
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 0a3222fd4442..7b0f7b624adf 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -2,6 +2,7 @@
 #include <linux/spinlock.h>
 #include <linux/slab.h>
 #include <linux/blkdev.h>
+#include <linux/smp_lock.h>
 #include <linux/hdreg.h>
 #include <linux/virtio.h>
 #include <linux/virtio_blk.h>
@@ -217,7 +218,7 @@ static int virtblk_get_id(struct gendisk *disk, char *id_str)
         return blk_execute_rq(vblk->disk->queue, vblk->disk, req, false);
 }
 
-static int virtblk_ioctl(struct block_device *bdev, fmode_t mode,
+static int virtblk_locked_ioctl(struct block_device *bdev, fmode_t mode,
                          unsigned cmd, unsigned long data)
 {
         struct gendisk *disk = bdev->bd_disk;
@@ -243,6 +244,18 @@ static int virtblk_ioctl(struct block_device *bdev, fmode_t mode,
                               (void __user *)data);
 }
 
+static int virtblk_ioctl(struct block_device *bdev, fmode_t mode,
+                             unsigned int cmd, unsigned long param)
+{
+        int ret;
+
+        lock_kernel();
+        ret = virtblk_locked_ioctl(bdev, mode, cmd, param);
+        unlock_kernel();
+
+        return ret;
+}
+
 /* We provide getgeo only to please some old bootloader/partitioning tools */
 static int virtblk_getgeo(struct block_device *bd, struct hd_geometry *geo)
 {
@@ -269,7 +282,7 @@ static int virtblk_getgeo(struct block_device *bd, struct hd_geometry *geo)
 }
 
 static const struct block_device_operations virtblk_fops = {
-        .locked_ioctl = virtblk_ioctl,
+        .ioctl  = virtblk_ioctl,
         .owner  = THIS_MODULE,
         .getgeo = virtblk_getgeo,
 };
diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index b16a3a926cf2..d5a3cd750561 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -46,6 +46,7 @@
 #include <linux/init.h>
 #include <linux/wait.h>
 #include <linux/blkdev.h>
+#include <linux/smp_lock.h>
 #include <linux/blkpg.h>
 #include <linux/delay.h>
 #include <linux/io.h>
@@ -133,7 +134,7 @@ static int xd_getgeo(struct block_device *bdev, struct hd_geometry *geo);
 
 static const struct block_device_operations xd_fops = {
         .owner  = THIS_MODULE,
-        .locked_ioctl   = xd_ioctl,
+        .ioctl  = xd_ioctl,
         .getgeo = xd_getgeo,
 };
 static DECLARE_WAIT_QUEUE_HEAD(xd_wait_int);
@@ -347,7 +348,7 @@ static int xd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 }
 
 /* xd_ioctl: handle device ioctl's */
-static int xd_ioctl(struct block_device *bdev, fmode_t mode, u_int cmd, u_long arg)
+static int xd_locked_ioctl(struct block_device *bdev, fmode_t mode, u_int cmd, u_long arg)
 {
         switch (cmd) {
                 case HDIO_SET_DMA:
@@ -375,6 +376,18 @@ static int xd_ioctl(struct block_device *bdev, fmode_t mode, u_int cmd, u_long a
         }
 }
 
+static int xd_ioctl(struct block_device *bdev, fmode_t mode,
+                             unsigned int cmd, unsigned long param)
+{
+        int ret;
+
+        lock_kernel();
+        ret = xd_locked_ioctl(bdev, mode, cmd, param);
+        unlock_kernel();
+
+        return ret;
+}
+
 /* xd_readwrite: handle a read/write request */
 static int xd_readwrite (u_char operation,XD_INFO *p,char *buffer,u_int block,u_int count)
 {
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 76af65b654e3..9119cd3d56a4 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -1045,7 +1045,7 @@ static const struct block_device_operations xlvbd_block_fops =
         .open = blkif_open,
         .release = blkif_release,
         .getgeo = blkif_getgeo,
-        .locked_ioctl = blkif_ioctl,
+        .ioctl = blkif_ioctl,
 };
 
 
diff --git a/drivers/cdrom/gdrom.c b/drivers/cdrom/gdrom.c
index 5219b57deb36..1772fd914fb9 100644
--- a/drivers/cdrom/gdrom.c
+++ b/drivers/cdrom/gdrom.c
@@ -34,6 +34,7 @@
 #include <linux/blkdev.h>
 #include <linux/interrupt.h>
 #include <linux/device.h>
+#include <linux/smp_lock.h>
 #include <linux/wait.h>
 #include <linux/workqueue.h>
 #include <linux/platform_device.h>
@@ -509,7 +510,13 @@ static int gdrom_bdops_mediachanged(struct gendisk *disk)
 static int gdrom_bdops_ioctl(struct block_device *bdev, fmode_t mode,
         unsigned cmd, unsigned long arg)
 {
-        return cdrom_ioctl(gd.cd_info, bdev, mode, cmd, arg);
+        int ret;
+
+        lock_kernel();
+        ret = cdrom_ioctl(gd.cd_info, bdev, mode, cmd, arg);
+        unlock_kernel();
+
+        return ret;
 }
 
 static const struct block_device_operations gdrom_bdops = {
@@ -517,7 +524,7 @@ static const struct block_device_operations gdrom_bdops = {
         .open                   = gdrom_bdops_open,
         .release                = gdrom_bdops_release,
         .media_changed          = gdrom_bdops_mediachanged,
-        .locked_ioctl           = gdrom_bdops_ioctl,
+        .ioctl                  = gdrom_bdops_ioctl,
 };
 
 static irqreturn_t gdrom_command_interrupt(int irq, void *dev_id)
diff --git a/drivers/cdrom/viocd.c b/drivers/cdrom/viocd.c
index 1fa6628d150b..16dada0627ee 100644
--- a/drivers/cdrom/viocd.c
+++ b/drivers/cdrom/viocd.c
@@ -42,6 +42,7 @@
 #include <linux/module.h>
 #include <linux/completion.h>
 #include <linux/proc_fs.h>
+#include <linux/smp_lock.h>
 #include <linux/seq_file.h>
 #include <linux/scatterlist.h>
 
@@ -167,7 +168,13 @@ static int viocd_blk_ioctl(struct block_device *bdev, fmode_t mode,
                 unsigned cmd, unsigned long arg)
 {
         struct disk_info *di = bdev->bd_disk->private_data;
-        return cdrom_ioctl(&di->viocd_info, bdev, mode, cmd, arg);
+        int ret;
+
+        lock_kernel();
+        ret = cdrom_ioctl(&di->viocd_info, bdev, mode, cmd, arg);
+        unlock_kernel();
+
+        return ret;
 }
 
 static int viocd_blk_media_changed(struct gendisk *disk)
@@ -180,7 +187,7 @@ static const struct block_device_operations viocd_fops = {
         .owner =                THIS_MODULE,
         .open =                 viocd_blk_open,
         .release =              viocd_blk_release,
-        .locked_ioctl =         viocd_blk_ioctl,
+        .ioctl =                viocd_blk_ioctl,
         .media_changed =        viocd_blk_media_changed,
 };
 
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index ef7e3a9bee51..bf9f61a5c2f8 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -31,6 +31,7 @@
 #include <linux/delay.h>
 #include <linux/timer.h>
 #include <linux/seq_file.h>
+#include <linux/smp_lock.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/errno.h>
@@ -1654,7 +1655,7 @@ static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
         return 0;
 }
 
-static int idecd_ioctl(struct block_device *bdev, fmode_t mode,
+static int idecd_locked_ioctl(struct block_device *bdev, fmode_t mode,
                         unsigned int cmd, unsigned long arg)
 {
         struct cdrom_info *info = ide_drv_g(bdev->bd_disk, cdrom_info);
@@ -1676,6 +1677,19 @@ static int idecd_ioctl(struct block_device *bdev, fmode_t mode,
         return err;
 }
 
+static int idecd_ioctl(struct block_device *bdev, fmode_t mode,
+                             unsigned int cmd, unsigned long arg)
+{
+        int ret;
+
+        lock_kernel();
+        ret = idecd_locked_ioctl(bdev, mode, cmd, arg);
+        unlock_kernel();
+
+        return ret;
+}
+
+
 static int idecd_media_changed(struct gendisk *disk)
 {
         struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
@@ -1696,7 +1710,7 @@ static const struct block_device_operations idecd_ops = {
         .owner                  = THIS_MODULE,
         .open                   = idecd_open,
         .release                = idecd_release,
-        .locked_ioctl           = idecd_ioctl,
+        .ioctl                  = idecd_ioctl,
         .media_changed          = idecd_media_changed,
         .revalidate_disk        = idecd_revalidate_disk
 };
diff --git a/drivers/ide/ide-disk_ioctl.c b/drivers/ide/ide-disk_ioctl.c
index 7b783dd7c0be..ec94c66918f6 100644
--- a/drivers/ide/ide-disk_ioctl.c
+++ b/drivers/ide/ide-disk_ioctl.c
@@ -1,6 +1,7 @@
 #include <linux/kernel.h>
 #include <linux/ide.h>
 #include <linux/hdreg.h>
+#include <linux/smp_lock.h>
 
 #include "ide-disk.h"
 
@@ -18,9 +19,13 @@ int ide_disk_ioctl(ide_drive_t *drive, struct block_device *bdev, fmode_t mode,
 {
         int err;
 
+        lock_kernel();
         err = ide_setting_ioctl(drive, bdev, cmd, arg, ide_disk_ioctl_settings);
         if (err != -EOPNOTSUPP)
-                return err;
+                goto out;
 
-        return generic_ide_ioctl(drive, bdev, cmd, arg);
+        err = generic_ide_ioctl(drive, bdev, cmd, arg);
+out:
+        unlock_kernel();
+        return err;
 }
diff --git a/drivers/ide/ide-floppy_ioctl.c b/drivers/ide/ide-floppy_ioctl.c
index 9c2288234dea..fd3d05ab3417 100644
--- a/drivers/ide/ide-floppy_ioctl.c
+++ b/drivers/ide/ide-floppy_ioctl.c
@@ -5,6 +5,7 @@
 #include <linux/kernel.h>
 #include <linux/ide.h>
 #include <linux/cdrom.h>
+#include <linux/smp_lock.h>
 
 #include <asm/unaligned.h>
 
@@ -275,12 +276,15 @@ int ide_floppy_ioctl(ide_drive_t *drive, struct block_device *bdev,
         void __user *argp = (void __user *)arg;
         int err;
 
-        if (cmd == CDROMEJECT || cmd == CDROM_LOCKDOOR)
-                return ide_floppy_lockdoor(drive, &pc, arg, cmd);
+        lock_kernel();
+        if (cmd == CDROMEJECT || cmd == CDROM_LOCKDOOR) {
+                err = ide_floppy_lockdoor(drive, &pc, arg, cmd);
+                goto out;
+        }
 
         err = ide_floppy_format_ioctl(drive, &pc, mode, cmd, argp);
         if (err != -ENOTTY)
-                return err;
+                goto out;
 
         /*
          * skip SCSI_IOCTL_SEND_COMMAND (deprecated)
@@ -293,5 +297,7 @@ int ide_floppy_ioctl(ide_drive_t *drive, struct block_device *bdev,
         if (err == -ENOTTY)
                 err = generic_ide_ioctl(drive, bdev, cmd, arg);
 
+out:
+        unlock_kernel();
         return err;
 }
diff --git a/drivers/ide/ide-gd.c b/drivers/ide/ide-gd.c
index c102d23d9b38..883f0c979c9f 100644
--- a/drivers/ide/ide-gd.c
+++ b/drivers/ide/ide-gd.c
@@ -323,7 +323,7 @@ static const struct block_device_operations ide_gd_ops = {
         .owner                  = THIS_MODULE,
         .open                   = ide_gd_open,
         .release                = ide_gd_release,
-        .locked_ioctl           = ide_gd_ioctl,
+        .ioctl                  = ide_gd_ioctl,
         .getgeo                 = ide_gd_getgeo,
         .media_changed          = ide_gd_media_changed,
         .unlock_native_capacity = ide_gd_unlock_native_capacity,
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index 635fd72d4728..39b0a5c45f07 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -32,6 +32,7 @@
 #include <linux/errno.h>
 #include <linux/genhd.h>
 #include <linux/seq_file.h>
+#include <linux/smp_lock.h>
 #include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/ide.h>
@@ -1927,9 +1928,14 @@ static int idetape_ioctl(struct block_device *bdev, fmode_t mode,
 {
         struct ide_tape_obj *tape = ide_drv_g(bdev->bd_disk, ide_tape_obj);
         ide_drive_t *drive = tape->drive;
-        int err = generic_ide_ioctl(drive, bdev, cmd, arg);
+        int err;
+
+        lock_kernel();
+        err = generic_ide_ioctl(drive, bdev, cmd, arg);
         if (err == -EINVAL)
                 err = idetape_blkdev_ioctl(drive, cmd, arg);
+        unlock_kernel();
+
         return err;
 }
 
@@ -1937,7 +1943,7 @@ static const struct block_device_operations idetape_block_ops = {
         .owner          = THIS_MODULE,
         .open           = idetape_open,
         .release        = idetape_release,
-        .locked_ioctl   = idetape_ioctl,
+        .ioctl          = idetape_ioctl,
 };
 
 static int ide_tape_probe(ide_drive_t *drive)
diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index b8233ff863e3..d1bdf8abe5db 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -53,7 +53,6 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/i2o.h>
-#include <linux/smp_lock.h>
 
 #include <linux/mempool.h>
 
@@ -653,40 +652,30 @@ static int i2o_block_ioctl(struct block_device *bdev, fmode_t mode,
 {
         struct gendisk *disk = bdev->bd_disk;
         struct i2o_block_device *dev = disk->private_data;
-        int ret = -ENOTTY;
 
         /* Anyone capable of this syscall can do *real bad* things */
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        lock_kernel();
         switch (cmd) {
         case BLKI2OGRSTRAT:
-                ret = put_user(dev->rcache, (int __user *)arg);
-                break;
+                return put_user(dev->rcache, (int __user *)arg);
         case BLKI2OGWSTRAT:
-                ret = put_user(dev->wcache, (int __user *)arg);
-                break;
+                return put_user(dev->wcache, (int __user *)arg);
         case BLKI2OSRSTRAT:
-                ret = -EINVAL;
                 if (arg < 0 || arg > CACHE_SMARTFETCH)
-                        break;
+                        return -EINVAL;
                 dev->rcache = arg;
-                ret = 0;
                 break;
         case BLKI2OSWSTRAT:
-                ret = -EINVAL;
                 if (arg != 0
                     && (arg < CACHE_WRITETHROUGH || arg > CACHE_SMARTBACK))
-                        break;
+                        return -EINVAL;
                 dev->wcache = arg;
-                ret = 0;
                 break;
         }
-        unlock_kernel();
-
-        return ret;
+        return -ENOTTY;
 };
 
 /**
@@ -942,7 +931,6 @@ static const struct block_device_operations i2o_block_fops = {
         .open = i2o_block_open,
         .release = i2o_block_release,
         .ioctl = i2o_block_ioctl,
-        .compat_ioctl = i2o_block_ioctl,
         .getgeo = i2o_block_getgeo,
         .media_changed = i2o_block_media_changed
 };
diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c
index 475af42745cb..8c83b11a77d5 100644
--- a/drivers/mtd/mtd_blkdevs.c
+++ b/drivers/mtd/mtd_blkdevs.c
@@ -15,6 +15,7 @@
 #include <linux/blkdev.h>
 #include <linux/blkpg.h>
 #include <linux/spinlock.h>
+#include <linux/smp_lock.h>
 #include <linux/hdreg.h>
 #include <linux/init.h>
 #include <linux/mutex.h>
@@ -237,6 +238,7 @@ static int blktrans_ioctl(struct block_device *bdev, fmode_t mode,
         if (!dev)
                 return ret;
 
+        lock_kernel();
         mutex_lock(&dev->lock);
 
         if (!dev->mtd)
@@ -250,6 +252,7 @@ static int blktrans_ioctl(struct block_device *bdev, fmode_t mode,
         }
 unlock:
         mutex_unlock(&dev->lock);
+        unlock_kernel();
         blktrans_dev_put(dev);
         return ret;
 }
@@ -258,7 +261,7 @@ static const struct block_device_operations mtd_blktrans_ops = {
         .owner          = THIS_MODULE,
         .open           = blktrans_open,
         .release        = blktrans_release,
-        .locked_ioctl   = blktrans_ioctl,
+        .ioctl          = blktrans_ioctl,
         .getgeo         = blktrans_getgeo,
 };
 
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 1d0c4b7c3b69..633ac32b25c1 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -46,6 +46,7 @@
 #include <linux/blkdev.h>
 #include <linux/blkpg.h>
 #include <linux/delay.h>
+#include <linux/smp_lock.h>
 #include <linux/mutex.h>
 #include <linux/string_helpers.h>
 #include <linux/async.h>
@@ -924,6 +925,7 @@ static int sd_ioctl(struct block_device *bdev, fmode_t mode,
         SCSI_LOG_IOCTL(1, printk("sd_ioctl: disk=%s, cmd=0x%x\n",
                                                 disk->disk_name, cmd));
 
+        lock_kernel();
         /*
          * If we are in the middle of error recovery, don't let anyone
          * else try and use this device.  Also, if error recovery fails, it
@@ -933,7 +935,7 @@ static int sd_ioctl(struct block_device *bdev, fmode_t mode,
         error = scsi_nonblockable_ioctl(sdp, cmd, p,
                                         (mode & FMODE_NDELAY) != 0);
         if (!scsi_block_when_processing_errors(sdp) || !error)
-                return error;
+                goto out;
 
         /*
          * Send SCSI addressing ioctls directly to mid level, send other
@@ -943,13 +945,18 @@ static int sd_ioctl(struct block_device *bdev, fmode_t mode,
         switch (cmd) {
                 case SCSI_IOCTL_GET_IDLUN:
                 case SCSI_IOCTL_GET_BUS_NUMBER:
-                        return scsi_ioctl(sdp, cmd, p);
+                        error = scsi_ioctl(sdp, cmd, p);
+                        break;
                 default:
                         error = scsi_cmd_ioctl(disk->queue, disk, mode, cmd, p);
                         if (error != -ENOTTY)
-                                return error;
+                                break;
+                        error = scsi_ioctl(sdp, cmd, p);
+                        break;
         }
-        return scsi_ioctl(sdp, cmd, p);
+out:
+        unlock_kernel();
+        return error;
 }
 
 static void set_media_not_present(struct scsi_disk *sdkp)
@@ -1123,7 +1130,7 @@ static const struct block_device_operations sd_fops = {
         .owner                  = THIS_MODULE,
         .open                   = sd_open,
         .release                = sd_release,
-        .locked_ioctl           = sd_ioctl,
+        .ioctl                  = sd_ioctl,
         .getgeo                 = sd_getgeo,
 #ifdef CONFIG_COMPAT
         .compat_ioctl           = sd_compat_ioctl,
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index 0a90abc7f140..d42fa6468f41 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -44,6 +44,7 @@
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/mutex.h>
+#include <linux/smp_lock.h>
 #include <linux/slab.h>
 #include <asm/uaccess.h>
 
@@ -493,6 +494,8 @@ static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
         void __user *argp = (void __user *)arg;
         int ret;
 
+        lock_kernel();
+
         /*
          * Send SCSI addressing ioctls directly to mid level, send other
          * ioctls to cdrom/block level.
@@ -500,12 +503,13 @@ static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
         switch (cmd) {
         case SCSI_IOCTL_GET_IDLUN:
         case SCSI_IOCTL_GET_BUS_NUMBER:
-                return scsi_ioctl(sdev, cmd, argp);
+                ret = scsi_ioctl(sdev, cmd, argp);
+                goto out;
         }
 
         ret = cdrom_ioctl(&cd->cdi, bdev, mode, cmd, arg);
         if (ret != -ENOSYS)
-                return ret;
+                goto out;
 
         /*
          * ENODEV means that we didn't recognise the ioctl, or that we
@@ -516,8 +520,12 @@ static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
         ret = scsi_nonblockable_ioctl(sdev, cmd, argp,
                                         (mode & FMODE_NDELAY) != 0);
         if (ret != -ENODEV)
-                return ret;
-        return scsi_ioctl(sdev, cmd, argp);
+                goto out;
+        ret = scsi_ioctl(sdev, cmd, argp);
+
+out:
+        unlock_kernel();
+        return ret;
 }
 
 static int sr_block_media_changed(struct gendisk *disk)
@@ -531,7 +539,7 @@ static const struct block_device_operations sr_bdops =
         .owner          = THIS_MODULE,
         .open           = sr_block_open,
         .release        = sr_block_release,
-        .locked_ioctl   = sr_block_ioctl,
+        .ioctl          = sr_block_ioctl,
         .media_changed  = sr_block_media_changed,
         /* 
          * No compat_ioctl for now because sr_block_ioctl never