20 files changed, 245 insertions, 233 deletions

diff --git a/drivers/char/hpet.c b/drivers/char/hpet.c
index a0a1829d3198..a4eee324eb1e 100644
--- a/drivers/char/hpet.c
+++ b/drivers/char/hpet.c
@@ -30,6 +30,7 @@
 #include <linux/bcd.h>
 #include <linux/seq_file.h>
 #include <linux/bitops.h>
+#include <linux/compat.h>
 #include <linux/clocksource.h>
 #include <linux/slab.h>
 
@@ -67,6 +68,7 @@
 #define read_counter(MC)        readl(MC)
 #endif
 
+static DEFINE_MUTEX(hpet_mutex); /* replaces BKL */
 static u32 hpet_nhpet, hpet_max_freq = HPET_USER_FREQ;
 
 /* This clocksource driver currently only works on ia64 */
@@ -250,7 +252,7 @@ static int hpet_open(struct inode *inode, struct file *file)
         if (file->f_mode & FMODE_WRITE)
                 return -EINVAL;
 
-        lock_kernel();
+        mutex_lock(&hpet_mutex);
         spin_lock_irq(&hpet_lock);
 
         for (devp = NULL, hpetp = hpets; hpetp && !devp; hpetp = hpetp->hp_next)
@@ -264,7 +266,7 @@ static int hpet_open(struct inode *inode, struct file *file)
 
         if (!devp) {
                 spin_unlock_irq(&hpet_lock);
-                unlock_kernel();
+                mutex_unlock(&hpet_mutex);
                 return -EBUSY;
         }
 
@@ -272,7 +274,7 @@ static int hpet_open(struct inode *inode, struct file *file)
         devp->hd_irqdata = 0;
         devp->hd_flags |= HPET_OPEN;
         spin_unlock_irq(&hpet_lock);
-        unlock_kernel();
+        mutex_unlock(&hpet_mutex);
 
         hpet_timer_set_irq(devp);
 
@@ -429,22 +431,6 @@ static int hpet_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int hpet_ioctl_common(struct hpet_dev *, int, unsigned long, int);
-
-static long hpet_ioctl(struct file *file, unsigned int cmd,
-                        unsigned long arg)
-{
-        struct hpet_dev *devp;
-        int ret;
-
-        devp = file->private_data;
-        lock_kernel();
-        ret = hpet_ioctl_common(devp, cmd, arg, 0);
-        unlock_kernel();
-
-        return ret;
-}
-
 static int hpet_ioctl_ieon(struct hpet_dev *devp)
 {
         struct hpet_timer __iomem *timer;
@@ -553,7 +539,8 @@ static inline unsigned long hpet_time_div(struct hpets *hpets,
 }
 
 static int
-hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
+hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg,
+                  struct hpet_info *info)
 {
         struct hpet_timer __iomem *timer;
         struct hpet __iomem *hpet;
@@ -594,23 +581,15 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
                 break;
         case HPET_INFO:
                 {
-                        struct hpet_info info;
-
                         if (devp->hd_ireqfreq)
-                                info.hi_ireqfreq =
+                                info->hi_ireqfreq =
                                         hpet_time_div(hpetp, devp->hd_ireqfreq);
                         else
-                                info.hi_ireqfreq = 0;
-                        info.hi_flags =
+                                info->hi_ireqfreq = 0;
+                        info->hi_flags =
                             readq(&timer->hpet_config) & Tn_PER_INT_CAP_MASK;
-                        info.hi_hpet = hpetp->hp_which;
-                        info.hi_timer = devp - hpetp->hp_dev;
-                        if (kernel)
-                                memcpy((void *)arg, &info, sizeof(info));
-                        else
-                                if (copy_to_user((void __user *)arg, &info,
-                                                 sizeof(info)))
-                                        err = -EFAULT;
+                        info->hi_hpet = hpetp->hp_which;
+                        info->hi_timer = devp - hpetp->hp_dev;
                         break;
                 }
         case HPET_EPI:
@@ -636,7 +615,7 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
                 devp->hd_flags &= ~HPET_PERIODIC;
                 break;
         case HPET_IRQFREQ:
-                if (!kernel && (arg > hpet_max_freq) &&
+                if ((arg > hpet_max_freq) &&
                     !capable(CAP_SYS_RESOURCE)) {
                         err = -EACCES;
                         break;
@@ -653,12 +632,63 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel)
         return err;
 }
 
+static long
+hpet_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+        struct hpet_info info;
+        int err;
+
+        mutex_lock(&hpet_mutex);
+        err = hpet_ioctl_common(file->private_data, cmd, arg, &info);
+        mutex_unlock(&hpet_mutex);
+
+        if ((cmd == HPET_INFO) && !err &&
+            (copy_to_user((void __user *)arg, &info, sizeof(info))))
+                err = -EFAULT;
+
+        return err;
+}
+
+#ifdef CONFIG_COMPAT
+struct compat_hpet_info {
+        compat_ulong_t hi_ireqfreq;     /* Hz */
+        compat_ulong_t hi_flags;        /* information */
+        unsigned short hi_hpet;
+        unsigned short hi_timer;
+};
+
+static long
+hpet_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+        struct hpet_info info;
+        int err;
+
+        mutex_lock(&hpet_mutex);
+        err = hpet_ioctl_common(file->private_data, cmd, arg, &info);
+        mutex_unlock(&hpet_mutex);
+
+        if ((cmd == HPET_INFO) && !err) {
+                struct compat_hpet_info __user *u = compat_ptr(arg);
+                if (put_user(info.hi_ireqfreq, &u->hi_ireqfreq) ||
+                    put_user(info.hi_flags, &u->hi_flags) ||
+                    put_user(info.hi_hpet, &u->hi_hpet) ||
+                    put_user(info.hi_timer, &u->hi_timer))
+                        err = -EFAULT;
+        }
+
+        return err;
+}
+#endif
+
 static const struct file_operations hpet_fops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
         .read = hpet_read,
         .poll = hpet_poll,
         .unlocked_ioctl = hpet_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl = hpet_compat_ioctl,
+#endif
         .open = hpet_open,
         .release = hpet_release,
         .fasync = hpet_fasync,
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index b38942f6bf31..24b2b9160aa6 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -19,8 +19,8 @@
 #include <linux/cdev.h>
 #include <linux/device.h>
 #include <linux/mutex.h>
-#include <linux/smp_lock.h>
 #include <linux/gfp.h>
+#include <linux/compat.h>
 
 #include <asm/uaccess.h>
 
@@ -55,7 +55,6 @@ static int raw_open(struct inode *inode, struct file *filp)
                 return 0;
         }
 
-        lock_kernel();
         mutex_lock(&raw_mutex);
 
         /*
@@ -82,7 +81,6 @@ static int raw_open(struct inode *inode, struct file *filp)
                         bdev->bd_inode->i_mapping;
         filp->private_data = bdev;
         mutex_unlock(&raw_mutex);
-        unlock_kernel();
         return 0;
 
 out2:
@@ -91,7 +89,6 @@ out1:
         blkdev_put(bdev, filp->f_mode);
 out:
         mutex_unlock(&raw_mutex);
-        unlock_kernel();
         return err;
 }
 
@@ -125,20 +122,84 @@ static long
 raw_ioctl(struct file *filp, unsigned int command, unsigned long arg)
 {
         struct block_device *bdev = filp->private_data;
-        int ret;
+        return blkdev_ioctl(bdev, 0, command, arg);
+}
+
+static int bind_set(int number, u64 major, u64 minor)
+{
+        dev_t dev = MKDEV(major, minor);
+        struct raw_device_data *rawdev;
+        int err = 0;
 
-        lock_kernel();
-        ret = blkdev_ioctl(bdev, 0, command, arg);
-        unlock_kernel();
+        if (number <= 0 || number >= MAX_RAW_MINORS)
+                return -EINVAL;
 
-        return ret;
+        if (MAJOR(dev) != major || MINOR(dev) != minor)
+                return -EINVAL;
+
+        rawdev = &raw_devices[number];
+
+        /*
+         * This is like making block devices, so demand the
+         * same capability
+         */
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        /*
+         * For now, we don't need to check that the underlying
+         * block device is present or not: we can do that when
+         * the raw device is opened.  Just check that the
+         * major/minor numbers make sense.
+         */
+
+        if (MAJOR(dev) == 0 && dev != 0)
+                return -EINVAL;
+
+        mutex_lock(&raw_mutex);
+        if (rawdev->inuse) {
+                mutex_unlock(&raw_mutex);
+                return -EBUSY;
+        }
+        if (rawdev->binding) {
+                bdput(rawdev->binding);
+                module_put(THIS_MODULE);
+        }
+        if (!dev) {
+                /* unbind */
+                rawdev->binding = NULL;
+                device_destroy(raw_class, MKDEV(RAW_MAJOR, number));
+        } else {
+                rawdev->binding = bdget(dev);
+                if (rawdev->binding == NULL) {
+                        err = -ENOMEM;
+                } else {
+                        dev_t raw = MKDEV(RAW_MAJOR, number);
+                        __module_get(THIS_MODULE);
+                        device_destroy(raw_class, raw);
+                        device_create(raw_class, NULL, raw, NULL,
+                                      "raw%d", number);
+                }
+        }
+        mutex_unlock(&raw_mutex);
+        return err;
 }
 
-static void bind_device(struct raw_config_request *rq)
+static int bind_get(int number, dev_t *dev)
 {
-        device_destroy(raw_class, MKDEV(RAW_MAJOR, rq->raw_minor));
-        device_create(raw_class, NULL, MKDEV(RAW_MAJOR, rq->raw_minor), NULL,
-                      "raw%d", rq->raw_minor);
+        struct raw_device_data *rawdev;
+        struct block_device *bdev;
+
+        if (number <= 0 || number >= MAX_RAW_MINORS)
+                return -EINVAL;
+
+        rawdev = &raw_devices[number];
+
+        mutex_lock(&raw_mutex);
+        bdev = rawdev->binding;
+        *dev = bdev ? bdev->bd_dev : 0;
+        mutex_unlock(&raw_mutex);
+        return 0;
 }
 
 /*
@@ -149,105 +210,78 @@ static long raw_ctl_ioctl(struct file *filp, unsigned int command,
                           unsigned long arg)
 {
         struct raw_config_request rq;
-        struct raw_device_data *rawdev;
-        int err = 0;
+        dev_t dev;
+        int err;
 
-        lock_kernel();
         switch (command) {
         case RAW_SETBIND:
+                if (copy_from_user(&rq, (void __user *) arg, sizeof(rq)))
+                        return -EFAULT;
+
+                return bind_set(rq.raw_minor, rq.block_major, rq.block_minor);
+
         case RAW_GETBIND:
+                if (copy_from_user(&rq, (void __user *) arg, sizeof(rq)))
+                        return -EFAULT;
 
-                /* First, find out which raw minor we want */
+                err = bind_get(rq.raw_minor, &dev);
+                if (err)
+                        return err;
 
-                if (copy_from_user(&rq, (void __user *) arg, sizeof(rq))) {
-                        err = -EFAULT;
-                        goto out;
-                }
+                rq.block_major = MAJOR(dev);
+                rq.block_minor = MINOR(dev);
 
-                if (rq.raw_minor <= 0 || rq.raw_minor >= MAX_RAW_MINORS) {
-                        err = -EINVAL;
-                        goto out;
-                }
-                rawdev = &raw_devices[rq.raw_minor];
-
-                if (command == RAW_SETBIND) {
-                        dev_t dev;
-
-                        /*
-                         * This is like making block devices, so demand the
-                         * same capability
-                         */
-                        if (!capable(CAP_SYS_ADMIN)) {
-                                err = -EPERM;
-                                goto out;
-                        }
-
-                        /*
-                         * For now, we don't need to check that the underlying
-                         * block device is present or not: we can do that when
-                         * the raw device is opened.  Just check that the
-                         * major/minor numbers make sense.
-                         */
-
-                        dev = MKDEV(rq.block_major, rq.block_minor);
-                        if ((rq.block_major == 0 && rq.block_minor != 0) ||
-                                        MAJOR(dev) != rq.block_major ||
-                                        MINOR(dev) != rq.block_minor) {
-                                err = -EINVAL;
-                                goto out;
-                        }
-
-                        mutex_lock(&raw_mutex);
-                        if (rawdev->inuse) {
-                                mutex_unlock(&raw_mutex);
-                                err = -EBUSY;
-                                goto out;
-                        }
-                        if (rawdev->binding) {
-                                bdput(rawdev->binding);
-                                module_put(THIS_MODULE);
-                        }
-                        if (rq.block_major == 0 && rq.block_minor == 0) {
-                                /* unbind */
-                                rawdev->binding = NULL;
-                                device_destroy(raw_class,
-                                                MKDEV(RAW_MAJOR, rq.raw_minor));
-                        } else {
-                                rawdev->binding = bdget(dev);
-                                if (rawdev->binding == NULL)
-                                        err = -ENOMEM;
-                                else {
-                                        __module_get(THIS_MODULE);
-                                        bind_device(&rq);
-                                }
-                        }
-                        mutex_unlock(&raw_mutex);
-                } else {
-                        struct block_device *bdev;
-
-                        mutex_lock(&raw_mutex);
-                        bdev = rawdev->binding;
-                        if (bdev) {
-                                rq.block_major = MAJOR(bdev->bd_dev);
-                                rq.block_minor = MINOR(bdev->bd_dev);
-                        } else {
-                                rq.block_major = rq.block_minor = 0;
-                        }
-                        mutex_unlock(&raw_mutex);
-                        if (copy_to_user((void __user *)arg, &rq, sizeof(rq))) {
-                                err = -EFAULT;
-                                goto out;
-                        }
-                }
-                break;
-        default:
-                err = -EINVAL;
-                break;
+                if (copy_to_user((void __user *)arg, &rq, sizeof(rq)))
+                        return -EFAULT;
+
+                return 0;
         }
-out:
-        unlock_kernel();
-        return err;
+
+        return -EINVAL;
+}
+
+#ifdef CONFIG_COMPAT
+struct raw32_config_request {
+        compat_int_t    raw_minor;
+        compat_u64      block_major;
+        compat_u64      block_minor;
+};
+
+static long raw_ctl_compat_ioctl(struct file *file, unsigned int cmd,
+                                unsigned long arg)
+{
+        struct raw32_config_request __user *user_req = compat_ptr(arg);
+        struct raw32_config_request rq;
+        dev_t dev;
+        int err = 0;
+
+        switch (cmd) {
+        case RAW_SETBIND:
+                if (copy_from_user(&rq, user_req, sizeof(rq)))
+                        return -EFAULT;
+
+                return bind_set(rq.raw_minor, rq.block_major, rq.block_minor);
+
+        case RAW_GETBIND:
+                if (copy_from_user(&rq, user_req, sizeof(rq)))
+                        return -EFAULT;
+
+                err = bind_get(rq.raw_minor, &dev);
+                if (err)
+                        return err;
+
+                rq.block_major = MAJOR(dev);
+                rq.block_minor = MINOR(dev);
+
+                if (copy_to_user(user_req, &rq, sizeof(rq)))
+                        return -EFAULT;
+
+                return 0;
+        }
+
+        return -EINVAL;
 }
+#endif
 
 static const struct file_operations raw_fops = {
         .read           = do_sync_read,
@@ -263,6 +297,9 @@ static const struct file_operations raw_fops = {
 
 static const struct file_operations raw_ctl_fops = {
         .unlocked_ioctl = raw_ctl_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl   = raw_ctl_compat_ioctl,
+#endif
         .open           = raw_open,
         .owner          = THIS_MODULE,
 };
diff --git a/drivers/char/tlclk.c b/drivers/char/tlclk.c
index 80ea6bcfffdc..e32cbf0c9a0b 100644
--- a/drivers/char/tlclk.c
+++ b/drivers/char/tlclk.c
@@ -37,7 +37,7 @@
 #include <linux/ioport.h>
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
-#include <linux/smp_lock.h>
+#include <linux/mutex.h>
 #include <linux/timer.h>
 #include <linux/sysfs.h>
 #include <linux/device.h>
@@ -206,7 +206,7 @@ static int tlclk_open(struct inode *inode, struct file *filp)
 {
         int result;
 
-        lock_kernel();
+        mutex_lock(&tlclk_mutex);
         if (test_and_set_bit(0, &useflags)) {
                 result = -EBUSY;
                 /* this legacy device is always one per system and it doesn't
@@ -229,7 +229,7 @@ static int tlclk_open(struct inode *inode, struct file *filp)
                 inb(TLCLK_REG6);        /* Clear interrupt events */
 
 out:
-        unlock_kernel();
+        mutex_unlock(&tlclk_mutex);
         return result;
 }
 
diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
index 4cab0c6397e3..7af443672626 100644
--- a/drivers/gpu/drm/Kconfig
+++ b/drivers/gpu/drm/Kconfig
@@ -73,7 +73,8 @@ source "drivers/gpu/drm/radeon/Kconfig"
 
 config DRM_I810
         tristate "Intel I810"
-        depends on DRM && AGP && AGP_INTEL
+        # BKL usage in order to avoid AB-BA deadlocks, may become BROKEN_ON_SMP
+        depends on DRM && AGP && AGP_INTEL && BKL
         help
           Choose this option if you have an Intel I810 graphics card.  If M is
           selected, the module will be called i810.  AGP support is required
@@ -86,6 +87,8 @@ choice
 
 config DRM_I830
         tristate "i830 driver"
+        # BKL usage in order to avoid AB-BA deadlocks, i830 may get removed
+        depends on BKL
         help
           Choose this option if you have a system that has Intel 830M, 845G,
           852GM, 855GM or 865G integrated graphics.  If M is selected, the
diff --git a/drivers/media/Kconfig b/drivers/media/Kconfig
index a28541b2b1a2..bad2cedb8d96 100644
--- a/drivers/media/Kconfig
+++ b/drivers/media/Kconfig
@@ -19,6 +19,7 @@ comment "Multimedia core support"
 
 config VIDEO_DEV
         tristate "Video For Linux"
+        depends on BKL # used in many drivers for ioctl handling, need to kill
         ---help---
           V4L core support for video capture and overlay devices, webcams and
           AM/FM radio cards.
diff --git a/drivers/media/dvb/bt8xx/dst_ca.c b/drivers/media/dvb/bt8xx/dst_ca.c
index cf8705162845..d75788b4e22e 100644
--- a/drivers/media/dvb/bt8xx/dst_ca.c
+++ b/drivers/media/dvb/bt8xx/dst_ca.c
@@ -22,7 +22,7 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
+#include <linux/mutex.h>
 #include <linux/string.h>
 #include <linux/dvb/ca.h>
 #include "dvbdev.h"
@@ -52,6 +52,7 @@
 } while(0)
 
 
+static DEFINE_MUTEX(dst_ca_mutex);
 static unsigned int verbose = 5;
 module_param(verbose, int, 0644);
 MODULE_PARM_DESC(verbose, "verbose startup messages, default is 1 (yes)");
@@ -564,7 +565,7 @@ static long dst_ca_ioctl(struct file *file, unsigned int cmd, unsigned long ioct
         void __user *arg = (void __user *)ioctl_arg;
         int result = 0;
 
-        lock_kernel();
+        mutex_lock(&dst_ca_mutex);
         dvbdev = file->private_data;
         state = (struct dst_state *)dvbdev->priv;
         p_ca_message = kmalloc(sizeof (struct ca_msg), GFP_KERNEL);
@@ -652,7 +653,7 @@ static long dst_ca_ioctl(struct file *file, unsigned int cmd, unsigned long ioct
         kfree (p_ca_slot_info);
         kfree (p_ca_caps);
 
-        unlock_kernel();
+        mutex_unlock(&dst_ca_mutex);
         return result;
 }
 
diff --git a/drivers/media/dvb/dvb-core/dmxdev.c b/drivers/media/dvb/dvb-core/dmxdev.c
index 0042306ea11b..2de13b04b09d 100644
--- a/drivers/media/dvb/dvb-core/dmxdev.c
+++ b/drivers/media/dvb/dvb-core/dmxdev.c
@@ -25,7 +25,6 @@
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/module.h>
-#include <linux/smp_lock.h>
 #include <linux/poll.h>
 #include <linux/ioctl.h>
 #include <linux/wait.h>
@@ -1088,13 +1087,7 @@ static int dvb_demux_do_ioctl(struct file *file,
 static long dvb_demux_ioctl(struct file *file, unsigned int cmd,
                             unsigned long arg)
 {
-        int ret;
-
-        lock_kernel();
-        ret = dvb_usercopy(file, cmd, arg, dvb_demux_do_ioctl);
-        unlock_kernel();
-
-        return ret;
+        return dvb_usercopy(file, cmd, arg, dvb_demux_do_ioctl);
 }
 
 static unsigned int dvb_demux_poll(struct file *file, poll_table *wait)
@@ -1186,13 +1179,7 @@ static int dvb_dvr_do_ioctl(struct file *file,
 static long dvb_dvr_ioctl(struct file *file,
                          unsigned int cmd, unsigned long arg)
 {
-        int ret;
-
-        lock_kernel();
-        ret = dvb_usercopy(file, cmd, arg, dvb_dvr_do_ioctl);
-        unlock_kernel();
-
-        return ret;
+        return dvb_usercopy(file, cmd, arg, dvb_dvr_do_ioctl);
 }
 
 static unsigned int dvb_dvr_poll(struct file *file, poll_table *wait)
diff --git a/drivers/media/dvb/dvb-core/dvb_ca_en50221.c b/drivers/media/dvb/dvb-core/dvb_ca_en50221.c
index cb97e6b85432..1723a984a522 100644
--- a/drivers/media/dvb/dvb-core/dvb_ca_en50221.c
+++ b/drivers/media/dvb/dvb-core/dvb_ca_en50221.c
@@ -1259,13 +1259,7 @@ static int dvb_ca_en50221_io_do_ioctl(struct file *file,
 static long dvb_ca_en50221_io_ioctl(struct file *file,
                                     unsigned int cmd, unsigned long arg)
 {
-        int ret;
-
-        lock_kernel();
-        ret = dvb_usercopy(file, cmd, arg, dvb_ca_en50221_io_do_ioctl);
-        unlock_kernel();
-
-        return ret;
+        return dvb_usercopy(file, cmd, arg, dvb_ca_en50221_io_do_ioctl);
 }
 
 
diff --git a/drivers/media/dvb/dvb-core/dvb_net.c b/drivers/media/dvb/dvb-core/dvb_net.c
index 6c3a8a06ccab..a08032284cbf 100644
--- a/drivers/media/dvb/dvb-core/dvb_net.c
+++ b/drivers/media/dvb/dvb-core/dvb_net.c
@@ -59,7 +59,6 @@
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
 #include <linux/dvb/net.h>
-#include <linux/smp_lock.h>
 #include <linux/uio.h>
 #include <asm/uaccess.h>
 #include <linux/crc32.h>
@@ -1445,13 +1444,7 @@ static int dvb_net_do_ioctl(struct file *file,
 static long dvb_net_ioctl(struct file *file,
               unsigned int cmd, unsigned long arg)
 {
-        int ret;
-
-        lock_kernel();
-        ret = dvb_usercopy(file, cmd, arg, dvb_net_do_ioctl);
-        unlock_kernel();
-
-        return ret;
+        return dvb_usercopy(file, cmd, arg, dvb_net_do_ioctl);
 }
 
 static int dvb_net_close(struct inode *inode, struct file *file)
diff --git a/drivers/media/dvb/dvb-core/dvbdev.c b/drivers/media/dvb/dvb-core/dvbdev.c
index b915c39d782f..28f486edcaf0 100644
--- a/drivers/media/dvb/dvb-core/dvbdev.c
+++ b/drivers/media/dvb/dvb-core/dvbdev.c
@@ -32,9 +32,9 @@
 #include <linux/fs.h>
 #include <linux/cdev.h>
 #include <linux/mutex.h>
-#include <linux/smp_lock.h>
 #include "dvbdev.h"
 
+static DEFINE_MUTEX(dvbdev_mutex);
 static int dvbdev_debug;
 
 module_param(dvbdev_debug, int, 0644);
@@ -68,7 +68,7 @@ static int dvb_device_open(struct inode *inode, struct file *file)
 {
         struct dvb_device *dvbdev;
 
-        lock_kernel();
+        mutex_lock(&dvbdev_mutex);
         down_read(&minor_rwsem);
         dvbdev = dvb_minors[iminor(inode)];
 
@@ -91,12 +91,12 @@ static int dvb_device_open(struct inode *inode, struct file *file)
                 }
                 fops_put(old_fops);
                 up_read(&minor_rwsem);
-                unlock_kernel();
+                mutex_unlock(&dvbdev_mutex);
                 return err;
         }
 fail:
         up_read(&minor_rwsem);
-        unlock_kernel();
+        mutex_unlock(&dvbdev_mutex);
         return -ENODEV;
 }
 
@@ -158,7 +158,6 @@ long dvb_generic_ioctl(struct file *file,
                        unsigned int cmd, unsigned long arg)
 {
         struct dvb_device *dvbdev = file->private_data;
-        int ret;
 
         if (!dvbdev)
                 return -ENODEV;
@@ -166,11 +165,7 @@ long dvb_generic_ioctl(struct file *file,
         if (!dvbdev->kernel_ioctl)
                 return -EINVAL;
 
-        lock_kernel();
-        ret = dvb_usercopy(file, cmd, arg, dvbdev->kernel_ioctl);
-        unlock_kernel();
-
-        return ret;
+        return dvb_usercopy(file, cmd, arg, dvbdev->kernel_ioctl);
 }
 EXPORT_SYMBOL(dvb_generic_ioctl);
 
@@ -421,8 +416,10 @@ int dvb_usercopy(struct file *file,
         }
 
         /* call driver */
+        mutex_lock(&dvbdev_mutex);
         if ((err = func(file, cmd, parg)) == -ENOIOCTLCMD)
                 err = -EINVAL;
+        mutex_unlock(&dvbdev_mutex);
 
         if (err < 0)
                 goto out;
diff --git a/drivers/media/video/dabusb.c b/drivers/media/video/dabusb.c
index 5b176bd7afdb..f3e25e91366d 100644
--- a/drivers/media/video/dabusb.c
+++ b/drivers/media/video/dabusb.c
@@ -32,7 +32,6 @@
 #include <linux/list.h>
 #include <linux/vmalloc.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <asm/uaccess.h>
 #include <asm/atomic.h>
@@ -621,7 +620,6 @@ static int dabusb_open (struct inode *inode, struct file *file)
         if (devnum < DABUSB_MINOR || devnum >= (DABUSB_MINOR + NRDABUSB))
                 return -EIO;
 
-        lock_kernel();
         s = &dabusb[devnum - DABUSB_MINOR];
 
         dbg("dabusb_open");
@@ -630,21 +628,17 @@ static int dabusb_open (struct inode *inode, struct file *file)
         while (!s->usbdev || s->opened) {
                 mutex_unlock(&s->mutex);
 
-                if (file->f_flags & O_NONBLOCK) {
+                if (file->f_flags & O_NONBLOCK)
                         return -EBUSY;
-                }
                 msleep_interruptible(500);
 
-                if (signal_pending (current)) {
-                        unlock_kernel();
+                if (signal_pending (current))
                         return -EAGAIN;
-                }
                 mutex_lock(&s->mutex);
         }
         if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
                 mutex_unlock(&s->mutex);
                 dev_err(&s->usbdev->dev, "set_interface failed\n");
-                unlock_kernel();
                 return -EINVAL;
         }
         s->opened = 1;
@@ -654,7 +648,6 @@ static int dabusb_open (struct inode *inode, struct file *file)
         file->private_data = s;
 
         r = nonseekable_open(inode, file);
-        unlock_kernel();
         return r;
 }
 
@@ -689,17 +682,13 @@ static long dabusb_ioctl (struct file *file, unsigned int cmd, unsigned long arg
 
         dbg("dabusb_ioctl");
 
-        lock_kernel();
-        if (s->remove_pending) {
-                unlock_kernel();
+        if (s->remove_pending)
                 return -EIO;
-        }
 
         mutex_lock(&s->mutex);
 
         if (!s->usbdev) {
                 mutex_unlock(&s->mutex);
-                unlock_kernel();
                 return -EIO;
         }
 
@@ -735,7 +724,6 @@ static long dabusb_ioctl (struct file *file, unsigned int cmd, unsigned long arg
                 break;
         }
         mutex_unlock(&s->mutex);
-        unlock_kernel();
         return ret;
 }
 
diff --git a/drivers/net/appletalk/Kconfig b/drivers/net/appletalk/Kconfig
index 0a0e0cd81a23..20f97e7017ce 100644
--- a/drivers/net/appletalk/Kconfig
+++ b/drivers/net/appletalk/Kconfig
@@ -3,6 +3,7 @@
 #
 config ATALK
         tristate "Appletalk protocol support"
+        depends on BKL # waiting to be removed from net/appletalk/ddp.c
         select LLC
         ---help---
           AppleTalk is the protocol that Apple computers can use to communicate
diff --git a/drivers/pnp/isapnp/proc.c b/drivers/pnp/isapnp/proc.c
index 3f94edab25fa..e73ebefdf3e0 100644
--- a/drivers/pnp/isapnp/proc.c
+++ b/drivers/pnp/isapnp/proc.c
@@ -31,8 +31,9 @@ static struct proc_dir_entry *isapnp_proc_bus_dir = NULL;
 static loff_t isapnp_proc_bus_lseek(struct file *file, loff_t off, int whence)
 {
         loff_t new = -1;
+        struct inode *inode = file->f_path.dentry->d_inode;
 
-        lock_kernel();
+        mutex_lock(&inode->i_mutex);
         switch (whence) {
         case 0:
                 new = off;
@@ -44,12 +45,12 @@ static loff_t isapnp_proc_bus_lseek(struct file *file, loff_t off, int whence)
                 new = 256 + off;
                 break;
         }
-        if (new < 0 || new > 256) {
-                unlock_kernel();
-                return -EINVAL;
-        }
-        unlock_kernel();
-        return (file->f_pos = new);
+        if (new < 0 || new > 256)
+                new = -EINVAL;
+        else
+                file->f_pos = new;
+        mutex_unlock(&inode->i_mutex);
+        return new;
 }
 
 static ssize_t isapnp_proc_bus_read(struct file *file, char __user * buf,
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 8373ca0de8e0..38e6fa9a2012 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -21,7 +21,6 @@
 #include <linux/hdreg.h>
 #include <linux/async.h>
 #include <linux/mutex.h>
-#include <linux/smp_lock.h>
 
 #include <asm/ccwdev.h>
 #include <asm/ebcdic.h>
@@ -2236,7 +2235,6 @@ static int dasd_open(struct block_device *bdev, fmode_t mode)
         if (!block)
                 return -ENODEV;
 
-        lock_kernel();
         base = block->base;
         atomic_inc(&block->open_count);
         if (test_bit(DASD_FLAG_OFFLINE, &base->flags)) {
@@ -2271,14 +2269,12 @@ static int dasd_open(struct block_device *bdev, fmode_t mode)
                 goto out;
         }
 
-        unlock_kernel();
         return 0;
 
 out:
         module_put(base->discipline->owner);
 unlock:
         atomic_dec(&block->open_count);
-        unlock_kernel();
         return rc;
 }
 
@@ -2286,10 +2282,8 @@ static int dasd_release(struct gendisk *disk, fmode_t mode)
 {
         struct dasd_block *block = disk->private_data;
 
-        lock_kernel();
         atomic_dec(&block->open_count);
         module_put(block->base->discipline->owner);
-        unlock_kernel();
         return 0;
 }
 
diff --git a/drivers/s390/block/dasd_ioctl.c b/drivers/s390/block/dasd_ioctl.c
index 1557214944f7..26075e95b1ba 100644
--- a/drivers/s390/block/dasd_ioctl.c
+++ b/drivers/s390/block/dasd_ioctl.c
@@ -16,7 +16,6 @@
 #include <linux/major.h>
 #include <linux/fs.h>
 #include <linux/blkpg.h>
-#include <linux/smp_lock.h>
 #include <linux/slab.h>
 #include <asm/compat.h>
 #include <asm/ccwdev.h>
@@ -370,9 +369,8 @@ static int dasd_ioctl_readall_cmb(struct dasd_block *block, unsigned int cmd,
         return ret;
 }
 
-static int
-dasd_do_ioctl(struct block_device *bdev, fmode_t mode,
-              unsigned int cmd, unsigned long arg)
+int dasd_ioctl(struct block_device *bdev, fmode_t mode,
+               unsigned int cmd, unsigned long arg)
 {
         struct dasd_block *block = bdev->bd_disk->private_data;
         void __user *argp;
@@ -430,14 +428,3 @@ dasd_do_ioctl(struct block_device *bdev, fmode_t mode,
                 return -EINVAL;
         }
 }
-
-int dasd_ioctl(struct block_device *bdev, fmode_t mode,
-               unsigned int cmd, unsigned long arg)
-{
-        int rc;
-
-        lock_kernel();
-        rc = dasd_do_ioctl(bdev, mode, cmd, arg);
-        unlock_kernel();
-        return rc;
-}
diff --git a/drivers/s390/block/dcssblk.c b/drivers/s390/block/dcssblk.c
index 2bd72aa34c59..9b43ae94beba 100644
--- a/drivers/s390/block/dcssblk.c
+++ b/drivers/s390/block/dcssblk.c
@@ -14,7 +14,6 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/blkdev.h>
-#include <linux/smp_lock.h>
 #include <linux/completion.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
@@ -776,7 +775,6 @@ dcssblk_open(struct block_device *bdev, fmode_t mode)
         struct dcssblk_dev_info *dev_info;
         int rc;
 
-        lock_kernel();
         dev_info = bdev->bd_disk->private_data;
         if (NULL == dev_info) {
                 rc = -ENODEV;
@@ -786,7 +784,6 @@ dcssblk_open(struct block_device *bdev, fmode_t mode)
         bdev->bd_block_size = 4096;
         rc = 0;
 out:
-        unlock_kernel();
         return rc;
 }
 
@@ -797,7 +794,6 @@ dcssblk_release(struct gendisk *disk, fmode_t mode)
         struct segment_info *entry;
         int rc;
 
-        lock_kernel();
         if (!dev_info) {
                 rc = -ENODEV;
                 goto out;
@@ -815,7 +811,6 @@ dcssblk_release(struct gendisk *disk, fmode_t mode)
         up_write(&dcssblk_devices_sem);
         rc = 0;
 out:
-        unlock_kernel();
         return rc;
 }
 
diff --git a/drivers/staging/cx25821/Kconfig b/drivers/staging/cx25821/Kconfig
index df7756a95fad..813cb355ac01 100644
--- a/drivers/staging/cx25821/Kconfig
+++ b/drivers/staging/cx25821/Kconfig
@@ -1,6 +1,7 @@
 config VIDEO_CX25821
         tristate "Conexant cx25821 support"
         depends on DVB_CORE && VIDEO_DEV && PCI && I2C && INPUT
+        depends on BKL # please fix
         select I2C_ALGOBIT
         select VIDEO_BTCX
         select VIDEO_TVEEPROM
diff --git a/drivers/staging/easycap/Kconfig b/drivers/staging/easycap/Kconfig
index bd96f39f2735..9d5fe4ddc30a 100644
--- a/drivers/staging/easycap/Kconfig
+++ b/drivers/staging/easycap/Kconfig
@@ -1,6 +1,7 @@
 config EASYCAP
         tristate "EasyCAP USB ID 05e1:0408 support"
         depends on USB && VIDEO_DEV
+        depends on BKL # please fix
 
         ---help---
           This is an integrated audio/video driver for EasyCAP cards with
diff --git a/drivers/staging/go7007/Kconfig b/drivers/staging/go7007/Kconfig
index e47f683a323e..75fa46805527 100644
--- a/drivers/staging/go7007/Kconfig
+++ b/drivers/staging/go7007/Kconfig
@@ -1,6 +1,7 @@
 config VIDEO_GO7007
         tristate "WIS GO7007 MPEG encoder support"
         depends on VIDEO_DEV && PCI && I2C && INPUT
+        depends on BKL # please fix
         depends on SND
         select VIDEOBUF_DMA_SG
         select VIDEO_IR
diff --git a/drivers/staging/usbip/Kconfig b/drivers/staging/usbip/Kconfig
index 2c1d10acb8b5..b11ec379b5c2 100644
--- a/drivers/staging/usbip/Kconfig
+++ b/drivers/staging/usbip/Kconfig
@@ -1,6 +1,6 @@
 config USB_IP_COMMON
         tristate "USB IP support (EXPERIMENTAL)"
-        depends on USB && NET && EXPERIMENTAL
+        depends on USB && NET && EXPERIMENTAL && BKL
         default N
         ---help---
           This enables pushing USB packets over IP to allow remote