Merge branch 'bkl-removal' of git://git.lwn.net/linux-2.6

* 'bkl-removal' of git://git.lwn.net/linux-2.6: (146 commits)
  IB/umad: BKL is not needed for ib_umad_open()
  IB/uverbs: BKL is not needed for ib_uverbs_open()
  bf561-coreb: BKL unneeded for open()
  Call fasync() functions without the BKL
  snd/PCM: fasync BKL pushdown
  ipmi: fasync BKL pushdown
  ecryptfs: fasync BKL pushdown
  Bluetooth VHCI: fasync BKL pushdown
  tty_io: fasync BKL pushdown
  tun: fasync BKL pushdown
  i2o: fasync BKL pushdown
  mpt: fasync BKL pushdown
  Remove BKL from remote_llseek v2
  Make FAT users happier by not deadlocking
  x86-mce: BKL pushdown
  vmwatchdog: BKL pushdown
  vmcp: BKL pushdown
  via-pmu: BKL pushdown
  uml-random: BKL pushdown
  uml-mmapper: BKL pushdown
  ...

29 files changed, 180 insertions, 59 deletions

diff --git a/arch/blackfin/mach-bf561/coreb.c b/arch/blackfin/mach-bf561/coreb.c
index 1b44e9e6dc3b..8598098c0840 100644
--- a/arch/blackfin/mach-bf561/coreb.c
+++ b/arch/blackfin/mach-bf561/coreb.c
@@ -194,6 +194,7 @@ static loff_t coreb_lseek(struct file *file, loff_t offset, int origin)
         return ret;
 }
 
+/* No BKL needed here */
 static int coreb_open(struct inode *inode, struct file *file)
 {
         spin_lock_irq(&coreb_lock);
diff --git a/arch/cris/arch-v10/drivers/eeprom.c b/arch/cris/arch-v10/drivers/eeprom.c
index f1cac9dc75b8..1f2ae909d3e6 100644
--- a/arch/cris/arch-v10/drivers/eeprom.c
+++ b/arch/cris/arch-v10/drivers/eeprom.c
@@ -28,6 +28,7 @@
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/smp_lock.h>
 #include <linux/wait.h>
 #include <asm/uaccess.h>
 #include "i2c.h"
@@ -375,10 +376,9 @@ int __init eeprom_init(void)
 }
 
 /* Opens the device. */
-
 static int eeprom_open(struct inode * inode, struct file * file)
 {
-
+  cycle_kernel_lock();
   if(iminor(inode) != EEPROM_MINOR_NR)
      return -ENXIO;
   if(imajor(inode) != EEPROM_MAJOR_NR)
diff --git a/arch/cris/arch-v10/drivers/gpio.c b/arch/cris/arch-v10/drivers/gpio.c
index 68a998bd1069..86048e697eb5 100644
--- a/arch/cris/arch-v10/drivers/gpio.c
+++ b/arch/cris/arch-v10/drivers/gpio.c
@@ -16,6 +16,7 @@
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/fs.h>
+#include <linux/smp_lock.h>
 #include <linux/string.h>
 #include <linux/poll.h>
 #include <linux/init.h>
@@ -323,6 +324,7 @@ gpio_open(struct inode *inode, struct file *filp)
         if (!priv)
                 return -ENOMEM;
 
+        lock_kernel();
         priv->minor = p;
 
         /* initialize the io/alarm struct */
@@ -357,6 +359,7 @@ gpio_open(struct inode *inode, struct file *filp)
         alarmlist = priv;
         spin_unlock_irqrestore(&gpio_lock, flags);
 
+        unlock_kernel();
         return 0;
 }
 
diff --git a/arch/cris/arch-v10/drivers/i2c.c b/arch/cris/arch-v10/drivers/i2c.c
index d6d22067d0c8..2797e67ce4f4 100644
--- a/arch/cris/arch-v10/drivers/i2c.c
+++ b/arch/cris/arch-v10/drivers/i2c.c
@@ -15,6 +15,7 @@
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
+#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/fs.h>
@@ -566,6 +567,7 @@ i2c_readreg(unsigned char theSlave, unsigned char theReg)
 static int
 i2c_open(struct inode *inode, struct file *filp)
 {
+        cycle_kernel_lock();
         return 0;
 }
 
diff --git a/arch/cris/arch-v10/drivers/sync_serial.c b/arch/cris/arch-v10/drivers/sync_serial.c
index 069546e342c5..91fea623c7c9 100644
--- a/arch/cris/arch-v10/drivers/sync_serial.c
+++ b/arch/cris/arch-v10/drivers/sync_serial.c
@@ -21,6 +21,7 @@
 #include <linux/interrupt.h>
 #include <linux/poll.h>
 #include <linux/init.h>
+#include <linux/smp_lock.h>
 #include <linux/timer.h>
 #include <asm/irq.h>
 #include <asm/dma.h>
@@ -443,18 +444,21 @@ static int sync_serial_open(struct inode *inode, struct file *file)
         int dev = MINOR(inode->i_rdev);
         struct sync_port *port;
         int mode;
+        int err = -EBUSY;
 
+        lock_kernel();
         DEBUG(printk(KERN_DEBUG "Open sync serial port %d\n", dev));
 
         if (dev < 0 || dev >= NUMBER_OF_PORTS || !ports[dev].enabled) {
                 DEBUG(printk(KERN_DEBUG "Invalid minor %d\n", dev));
-                return -ENODEV;
+                err = -ENODEV;
+                goto out;
         }
         port = &ports[dev];
         /* Allow open this device twice (assuming one reader and one writer) */
         if (port->busy == 2) {
                 DEBUG(printk(KERN_DEBUG "Device is busy.. \n"));
-                return -EBUSY;
+                goto out;
         }
         if (port->init_irqs) {
                 if (port->use_dma) {
@@ -465,14 +469,14 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                                 &ports[0])) {
                                         printk(KERN_CRIT "Can't alloc "
                                                 "sync serial port 1 IRQ");
-                                        return -EBUSY;
+                                        goto out;
                                 } else if (request_irq(25, rx_interrupt, 0,
                                                 "synchronous serial 1 dma rx",
                                                 &ports[0])) {
                                         free_irq(24, &port[0]);
                                         printk(KERN_CRIT "Can't alloc "
                                                 "sync serial port 1 IRQ");
-                                        return -EBUSY;
+                                        goto out;
                                 } else if (cris_request_dma(8,
                                                 "synchronous serial 1 dma tr",
                                                 DMA_VERBOSE_ON_ERROR,
@@ -482,7 +486,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                         printk(KERN_CRIT "Can't alloc "
                                                 "sync serial port 1 "
                                                 "TX DMA channel");
-                                        return -EBUSY;
+                                        goto out;
                                 } else if (cris_request_dma(9,
                                                 "synchronous serial 1 dma rec",
                                                 DMA_VERBOSE_ON_ERROR,
@@ -493,7 +497,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                         printk(KERN_CRIT "Can't alloc "
                                                 "sync serial port 1 "
                                                 "RX DMA channel");
-                                        return -EBUSY;
+                                        goto out;
                                 }
 #endif
                                 RESET_DMA(8); WAIT_DMA(8);
@@ -520,14 +524,14 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                                 &ports[1])) {
                                         printk(KERN_CRIT "Can't alloc "
                                                 "sync serial port 3 IRQ");
-                                        return -EBUSY;
+                                        goto out;
                                 } else if (request_irq(21, rx_interrupt, 0,
                                                 "synchronous serial 3 dma rx",
                                                 &ports[1])) {
                                         free_irq(20, &ports[1]);
                                         printk(KERN_CRIT "Can't alloc "
                                                 "sync serial port 3 IRQ");
-                                        return -EBUSY;
+                                        goto out;
                                 } else if (cris_request_dma(4,
                                                 "synchronous serial 3 dma tr",
                                                 DMA_VERBOSE_ON_ERROR,
@@ -537,7 +541,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                         printk(KERN_CRIT "Can't alloc "
                                                 "sync serial port 3 "
                                                 "TX DMA channel");
-                                        return -EBUSY;
+                                        goto out;
                                 } else if (cris_request_dma(5,
                                                 "synchronous serial 3 dma rec",
                                                 DMA_VERBOSE_ON_ERROR,
@@ -548,7 +552,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                         printk(KERN_CRIT "Can't alloc "
                                                 "sync serial port 3 "
                                                 "RX DMA channel");
-                                        return -EBUSY;
+                                        goto out;
                                 }
 #endif
                                 RESET_DMA(4); WAIT_DMA(4);
@@ -581,7 +585,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                                 &ports[0])) {
                                         printk(KERN_CRIT "Can't alloc "
                                                 "sync serial manual irq");
-                                        return -EBUSY;
+                                        goto out;
                                 }
                         } else if (port == &ports[1]) {
                                 if (request_irq(8,
@@ -591,7 +595,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                                 &ports[1])) {
                                         printk(KERN_CRIT "Can't alloc "
                                                 "sync serial manual irq");
-                                        return -EBUSY;
+                                        goto out;
                                 }
                         }
                         port->init_irqs = 0;
@@ -620,7 +624,11 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                         *R_IRQ_MASK1_SET = 1 << port->data_avail_bit;
                 DEBUG(printk(KERN_DEBUG "sser%d rec started\n", dev));
         }
-        return 0;
+        ret = 0;
+        
+out:
+        unlock_kernel();
+        return ret;
 }
 
 static int sync_serial_release(struct inode *inode, struct file *file)
diff --git a/arch/cris/arch-v32/drivers/cryptocop.c b/arch/cris/arch-v32/drivers/cryptocop.c
index 9fb58202be99..67c61ea86813 100644
--- a/arch/cris/arch-v32/drivers/cryptocop.c
+++ b/arch/cris/arch-v32/drivers/cryptocop.c
@@ -11,6 +11,7 @@
 #include <linux/string.h>
 #include <linux/fs.h>
 #include <linux/mm.h>
+#include <linux/smp_lock.h>
 #include <linux/spinlock.h>
 #include <linux/stddef.h>
 
@@ -2302,11 +2303,11 @@ static int cryptocop_job_setup(struct cryptocop_prio_job **pj, struct cryptocop_
         return 0;
 }
 
-
 static int cryptocop_open(struct inode *inode, struct file *filp)
 {
         int p = iminor(inode);
 
+        cycle_kernel_lock();
         if (p != CRYPTOCOP_MINOR) return -EINVAL;
 
         filp->private_data = NULL;
diff --git a/arch/cris/arch-v32/drivers/i2c.c b/arch/cris/arch-v32/drivers/i2c.c
index c2fb7a5c1396..179e7b804331 100644
--- a/arch/cris/arch-v32/drivers/i2c.c
+++ b/arch/cris/arch-v32/drivers/i2c.c
@@ -33,6 +33,7 @@
 #include <linux/fs.h>
 #include <linux/string.h>
 #include <linux/init.h>
+#include <linux/smp_lock.h>
 
 #include <asm/etraxi2c.h>
 
@@ -636,6 +637,7 @@ i2c_readreg(unsigned char theSlave, unsigned char theReg)
 static int
 i2c_open(struct inode *inode, struct file *filp)
 {
+        cycle_kernel_lock();
         return 0;
 }
 
diff --git a/arch/cris/arch-v32/drivers/mach-a3/gpio.c b/arch/cris/arch-v32/drivers/mach-a3/gpio.c
index de107dad9f4f..ef98608e5067 100644
--- a/arch/cris/arch-v32/drivers/mach-a3/gpio.c
+++ b/arch/cris/arch-v32/drivers/mach-a3/gpio.c
@@ -23,6 +23,7 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
+#include <linux/smp_lock.h>
 
 #include <asm/etraxgpio.h>
 #include <hwregs/reg_map.h>
@@ -390,6 +391,8 @@ static int gpio_open(struct inode *inode, struct file *filp)
 
         if (!priv)
                 return -ENOMEM;
+
+        lock_kernel();
         memset(priv, 0, sizeof(*priv));
 
         priv->minor = p;
@@ -412,6 +415,7 @@ static int gpio_open(struct inode *inode, struct file *filp)
                 spin_unlock_irq(&gpio_lock);
         }
 
+        unlock_kernel();
         return 0;
 }
 
diff --git a/arch/cris/arch-v32/drivers/mach-fs/gpio.c b/arch/cris/arch-v32/drivers/mach-fs/gpio.c
index 7863fd4efc2b..fe1fde893887 100644
--- a/arch/cris/arch-v32/drivers/mach-fs/gpio.c
+++ b/arch/cris/arch-v32/drivers/mach-fs/gpio.c
@@ -22,6 +22,7 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
+#include <linux/smp_lock.h>
 
 #include <asm/etraxgpio.h>
 #include <hwregs/reg_map.h>
@@ -426,9 +427,10 @@ gpio_open(struct inode *inode, struct file *filp)
                 return -EINVAL;
 
         priv = kmalloc(sizeof(struct gpio_private), GFP_KERNEL);
-
         if (!priv)
                 return -ENOMEM;
+
+        lock_kernel();
         memset(priv, 0, sizeof(*priv));
 
         priv->minor = p;
@@ -449,6 +451,7 @@ gpio_open(struct inode *inode, struct file *filp)
         alarmlist = priv;
         spin_unlock_irq(&alarm_lock);
 
+        unlock_kernel();
         return 0;
 }
 
diff --git a/arch/cris/arch-v32/drivers/sync_serial.c b/arch/cris/arch-v32/drivers/sync_serial.c
index 47c377df6fb3..d2a0fbf5341f 100644
--- a/arch/cris/arch-v32/drivers/sync_serial.c
+++ b/arch/cris/arch-v32/drivers/sync_serial.c
@@ -14,6 +14,7 @@
 #include <linux/major.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
+#include <linux/smp_lock.h>
 #include <linux/interrupt.h>
 #include <linux/poll.h>
 #include <linux/init.h>
@@ -429,23 +430,26 @@ static inline int sync_data_avail_to_end(struct sync_port *port)
 static int sync_serial_open(struct inode *inode, struct file *file)
 {
         int dev = iminor(inode);
+        int ret = -EBUSY;
         sync_port *port;
         reg_dma_rw_cfg cfg = {.en = regk_dma_yes};
         reg_dma_rw_intr_mask intr_mask = {.data = regk_dma_yes};
 
+        lock_kernel();
         DEBUG(printk(KERN_DEBUG "Open sync serial port %d\n", dev));
 
         if (dev < 0 || dev >= NBR_PORTS || !ports[dev].enabled)
         {
                 DEBUG(printk(KERN_DEBUG "Invalid minor %d\n", dev));
-                return -ENODEV;
+                ret = -ENODEV;
+                goto out;
         }
         port = &ports[dev];
         /* Allow open this device twice (assuming one reader and one writer) */
         if (port->busy == 2)
         {
                 DEBUG(printk(KERN_DEBUG "Device is busy.. \n"));
-                return -EBUSY;
+                goto out;
         }
 
 
@@ -459,7 +463,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                                 "synchronous serial 0 dma tr",
                                                 &ports[0])) {
                                         printk(KERN_CRIT "Can't allocate sync serial port 0 IRQ");
-                                        return -EBUSY;
+                                        goto out;
                                 } else if (request_irq(DMA_IN_INTR_VECT,
                                                 rx_interrupt,
                                                 0,
@@ -467,7 +471,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                                 &ports[0])) {
                                         free_irq(DMA_OUT_INTR_VECT, &port[0]);
                                         printk(KERN_CRIT "Can't allocate sync serial port 0 IRQ");
-                                        return -EBUSY;
+                                        goto out;
                                 } else if (crisv32_request_dma(OUT_DMA_NBR,
                                                 "synchronous serial 0 dma tr",
                                                 DMA_VERBOSE_ON_ERROR,
@@ -476,7 +480,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                         free_irq(DMA_OUT_INTR_VECT, &port[0]);
                                         free_irq(DMA_IN_INTR_VECT, &port[0]);
                                         printk(KERN_CRIT "Can't allocate sync serial port 0 TX DMA channel");
-                                        return -EBUSY;
+                                        goto out;
                                 } else if (crisv32_request_dma(IN_DMA_NBR,
                                                 "synchronous serial 0 dma rec",
                                                 DMA_VERBOSE_ON_ERROR,
@@ -486,7 +490,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                         free_irq(DMA_OUT_INTR_VECT, &port[0]);
                                         free_irq(DMA_IN_INTR_VECT, &port[0]);
                                         printk(KERN_CRIT "Can't allocate sync serial port 1 RX DMA channel");
-                                        return -EBUSY;
+                                        goto out;
                                 }
 #endif
                         }
@@ -499,7 +503,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                                 "synchronous serial 1 dma tr",
                                                 &ports[1])) {
                                         printk(KERN_CRIT "Can't allocate sync serial port 1 IRQ");
-                                        return -EBUSY;
+                                        goto out;
                                 } else if (request_irq(DMA7_INTR_VECT,
                                                        rx_interrupt,
                                                        0,
@@ -507,7 +511,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                                        &ports[1])) {
                                         free_irq(DMA6_INTR_VECT, &ports[1]);
                                         printk(KERN_CRIT "Can't allocate sync serial port 3 IRQ");
-                                        return -EBUSY;
+                                        goto out;
                                 } else if (crisv32_request_dma(
                                                 SYNC_SER1_TX_DMA_NBR,
                                                 "synchronous serial 1 dma tr",
@@ -517,7 +521,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                         free_irq(DMA6_INTR_VECT, &ports[1]);
                                         free_irq(DMA7_INTR_VECT, &ports[1]);
                                         printk(KERN_CRIT "Can't allocate sync serial port 3 TX DMA channel");
-                                        return -EBUSY;
+                                        goto out;
                                 } else if (crisv32_request_dma(
                                                 SYNC_SER1_RX_DMA_NBR,
                                                 "synchronous serial 3 dma rec",
@@ -528,7 +532,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                         free_irq(DMA6_INTR_VECT, &ports[1]);
                                         free_irq(DMA7_INTR_VECT, &ports[1]);
                                         printk(KERN_CRIT "Can't allocate sync serial port 3 RX DMA channel");
-                                        return -EBUSY;
+                                        goto out;
                                 }
 #endif
                         }
@@ -554,7 +558,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                                 "synchronous serial manual irq",
                                                 &ports[0])) {
                                         printk("Can't allocate sync serial manual irq");
-                                        return -EBUSY;
+                                        goto out;
                                 }
                         }
 #ifdef CONFIG_ETRAXFS
@@ -565,7 +569,7 @@ static int sync_serial_open(struct inode *inode, struct file *file)
                                                 "synchronous serial manual irq",
                                                 &ports[1])) {
                                         printk(KERN_CRIT "Can't allocate sync serial manual irq");
-                                        return -EBUSY;
+                                        goto out;
                                 }
                         }
 #endif
@@ -578,7 +582,10 @@ static int sync_serial_open(struct inode *inode, struct file *file)
         } /* port->init_irqs */
 
         port->busy++;
-        return 0;
+        ret = 0;
+out:
+        unlock_kernel();
+        return ret;
 }
 
 static int sync_serial_release(struct inode *inode, struct file *file)
diff --git a/arch/m68k/bvme6000/rtc.c b/arch/m68k/bvme6000/rtc.c
index a812d03879f8..e8ac3f7d72df 100644
--- a/arch/m68k/bvme6000/rtc.c
+++ b/arch/m68k/bvme6000/rtc.c
@@ -10,6 +10,7 @@
 #include <linux/errno.h>
 #include <linux/miscdevice.h>
 #include <linux/slab.h>
+#include <linux/smp_lock.h>
 #include <linux/ioport.h>
 #include <linux/capability.h>
 #include <linux/fcntl.h>
@@ -140,10 +141,14 @@ static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 
 static int rtc_open(struct inode *inode, struct file *file)
 {
-        if(rtc_status)
+        lock_kernel();
+        if(rtc_status) {
+                unlock_kernel();
                 return -EBUSY;
+        }
 
         rtc_status = 1;
+        unlock_kernel();
         return 0;
 }
 
diff --git a/arch/m68k/mvme16x/rtc.c b/arch/m68k/mvme16x/rtc.c
index e341387787ab..432a9f13b2ed 100644
--- a/arch/m68k/mvme16x/rtc.c
+++ b/arch/m68k/mvme16x/rtc.c
@@ -10,6 +10,7 @@
 #include <linux/errno.h>
 #include <linux/miscdevice.h>
 #include <linux/slab.h>
+#include <linux/smp_lock.h>
 #include <linux/ioport.h>
 #include <linux/capability.h>
 #include <linux/fcntl.h>
@@ -127,11 +128,14 @@ static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 
 static int rtc_open(struct inode *inode, struct file *file)
 {
+        lock_kernel();
         if( !atomic_dec_and_test(&rtc_ready) )
         {
                 atomic_inc( &rtc_ready );
+                unlock_kernel();
                 return -EBUSY;
         }
+        unlock_kernel();
 
         return 0;
 }
diff --git a/arch/mips/basler/excite/excite_iodev.c b/arch/mips/basler/excite/excite_iodev.c
index 476d20e08d0e..a1e3526b4a94 100644
--- a/arch/mips/basler/excite/excite_iodev.c
+++ b/arch/mips/basler/excite/excite_iodev.c
@@ -26,6 +26,7 @@
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
 #include <linux/miscdevice.h>
+#include <linux/smp_lock.h>
 
 #include "excite_iodev.h"
 
@@ -110,8 +111,14 @@ static int __exit iodev_remove(struct device *dev)
 
 static int iodev_open(struct inode *i, struct file *f)
 {
-        return request_irq(iodev_irq, iodev_irqhdl, IRQF_DISABLED,
+        int ret;
+
+        lock_kernel();
+        ret = request_irq(iodev_irq, iodev_irqhdl, IRQF_DISABLED,
                            iodev_name, &miscdev);
+        unlock_kernel();
+
+        return ret;
 }
 
 static int iodev_release(struct inode *i, struct file *f)
diff --git a/arch/mips/kernel/rtlx.c b/arch/mips/kernel/rtlx.c
index b88f1c18ff4d..b55641961232 100644
--- a/arch/mips/kernel/rtlx.c
+++ b/arch/mips/kernel/rtlx.c
@@ -28,6 +28,7 @@
 #include <linux/vmalloc.h>
 #include <linux/elf.h>
 #include <linux/seq_file.h>
+#include <linux/smp_lock.h>
 #include <linux/syscalls.h>
 #include <linux/moduleloader.h>
 #include <linux/interrupt.h>
@@ -392,8 +393,12 @@ out:
 static int file_open(struct inode *inode, struct file *filp)
 {
         int minor = iminor(inode);
+        int err;
 
-        return rtlx_open(minor, (filp->f_flags & O_NONBLOCK) ? 0 : 1);
+        lock_kernel();
+        err = rtlx_open(minor, (filp->f_flags & O_NONBLOCK) ? 0 : 1);
+        unlock_kernel();
+        return err;
 }
 
 static int file_release(struct inode *inode, struct file *filp)
diff --git a/arch/mips/kernel/vpe.c b/arch/mips/kernel/vpe.c
index 2794501ff302..972b2d2b8401 100644
--- a/arch/mips/kernel/vpe.c
+++ b/arch/mips/kernel/vpe.c
@@ -38,6 +38,7 @@
 #include <linux/vmalloc.h>
 #include <linux/elf.h>
 #include <linux/seq_file.h>
+#include <linux/smp_lock.h>
 #include <linux/syscalls.h>
 #include <linux/moduleloader.h>
 #include <linux/interrupt.h>
@@ -1050,17 +1051,20 @@ static int vpe_open(struct inode *inode, struct file *filp)
         enum vpe_state state;
         struct vpe_notifications *not;
         struct vpe *v;
-        int ret;
+        int ret, err = 0;
 
+        lock_kernel();
         if (minor != iminor(inode)) {
                 /* assume only 1 device at the moment. */
                 printk(KERN_WARNING "VPE loader: only vpe1 is supported\n");
-                return -ENODEV;
+                err = -ENODEV;
+                goto out;
         }
 
         if ((v = get_vpe(tclimit)) == NULL) {
                 printk(KERN_WARNING "VPE loader: unable to get vpe\n");
-                return -ENODEV;
+                err = -ENODEV;
+                goto out;
         }
 
         state = xchg(&v->state, VPE_STATE_INUSE);
@@ -1100,6 +1104,8 @@ static int vpe_open(struct inode *inode, struct file *filp)
         v->shared_ptr = NULL;
         v->__start = 0;
 
+out:
+        unlock_kernel();
         return 0;
 }
 
diff --git a/arch/mips/sibyte/common/sb_tbprof.c b/arch/mips/sibyte/common/sb_tbprof.c
index 63b444eaf01e..28b012ab8dcb 100644
--- a/arch/mips/sibyte/common/sb_tbprof.c
+++ b/arch/mips/sibyte/common/sb_tbprof.c
@@ -28,6 +28,7 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
+#include <linux/smp_lock.h>
 #include <linux/vmalloc.h>
 #include <linux/fs.h>
 #include <linux/errno.h>
@@ -402,18 +403,26 @@ static int sbprof_zbprof_stop(void)
 static int sbprof_tb_open(struct inode *inode, struct file *filp)
 {
         int minor;
+        int err = 0;
 
+        lock_kernel();
         minor = iminor(inode);
-        if (minor != 0)
-                return -ENODEV;
+        if (minor != 0) {
+                err = -ENODEV;
+                goto out;
+        }
 
-        if (xchg(&sbp.open, SB_OPENING) != SB_CLOSED)
-                return -EBUSY;
+        if (xchg(&sbp.open, SB_OPENING) != SB_CLOSED) {
+                err = -EBUSY;
+                goto out;
+        }
 
         memset(&sbp, 0, sizeof(struct sbprof_tb));
         sbp.sbprof_tbbuf = vmalloc(MAX_TBSAMPLE_BYTES);
-        if (!sbp.sbprof_tbbuf)
-                return -ENOMEM;
+        if (!sbp.sbprof_tbbuf) {
+                err = -ENOMEM;
+                goto out;
+        }
         memset(sbp.sbprof_tbbuf, 0, MAX_TBSAMPLE_BYTES);
         init_waitqueue_head(&sbp.tb_sync);
         init_waitqueue_head(&sbp.tb_read);
@@ -421,7 +430,9 @@ static int sbprof_tb_open(struct inode *inode, struct file *filp)
 
         sbp.open = SB_OPEN;
 
-        return 0;
+  out:
+        unlock_kernel();
+        return err;
 }
 
 static int sbprof_tb_release(struct inode *inode, struct file *filp)
diff --git a/arch/parisc/kernel/perf.c b/arch/parisc/kernel/perf.c
index 89d6d5ad44b5..f696f57faa15 100644
--- a/arch/parisc/kernel/perf.c
+++ b/arch/parisc/kernel/perf.c
@@ -46,6 +46,7 @@
 #include <linux/init.h>
 #include <linux/proc_fs.h>
 #include <linux/miscdevice.h>
+#include <linux/smp_lock.h>
 #include <linux/spinlock.h>
 
 #include <asm/uaccess.h>
@@ -260,13 +261,16 @@ printk("Preparing to start counters\n");
  */
 static int perf_open(struct inode *inode, struct file *file)
 {
+        lock_kernel();
         spin_lock(&perf_lock);
         if (perf_enabled) {
                 spin_unlock(&perf_lock);
+                unlock_kernel();
                 return -EBUSY;
         }
         perf_enabled = 1;
         spin_unlock(&perf_lock);
+        unlock_kernel();
 
         return 0;
 }
diff --git a/arch/s390/crypto/prng.c b/arch/s390/crypto/prng.c
index 6a4300b3ff52..eca724d229ec 100644
--- a/arch/s390/crypto/prng.c
+++ b/arch/s390/crypto/prng.c
@@ -6,6 +6,7 @@
 #include <linux/fs.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/smp_lock.h>
 #include <linux/miscdevice.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
@@ -48,6 +49,7 @@ static unsigned char parm_block[32] = {
 
 static int prng_open(struct inode *inode, struct file *file)
 {
+        cycle_kernel_lock();
         return nonseekable_open(inode, file);
 }
 
diff --git a/arch/sh/boards/landisk/gio.c b/arch/sh/boards/landisk/gio.c
index 17025080db35..0c15b0a50b99 100644
--- a/arch/sh/boards/landisk/gio.c
+++ b/arch/sh/boards/landisk/gio.c
@@ -14,6 +14,7 @@
  */
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/smp_lock.h>
 #include <linux/kdev_t.h>
 #include <linux/cdev.h>
 #include <linux/fs.h>
@@ -32,17 +33,20 @@ static int openCnt;
 static int gio_open(struct inode *inode, struct file *filp)
 {
         int minor;
+        int ret = -ENOENT;
 
+        lock_kernel();
         minor = MINOR(inode->i_rdev);
         if (minor < DEVCOUNT) {
                 if (openCnt > 0) {
-                        return -EALREADY;
+                        ret = -EALREADY;
                 } else {
                         openCnt++;
-                        return 0;
+                        ret = 0;
                 }
         }
-        return -ENOENT;
+        unlock_kernel();
+        return ret;
 }
 
 static int gio_close(struct inode *inode, struct file *filp)
diff --git a/arch/sparc/kernel/apc.c b/arch/sparc/kernel/apc.c
index d06a405ca718..6707422c9847 100644
--- a/arch/sparc/kernel/apc.c
+++ b/arch/sparc/kernel/apc.c
@@ -10,6 +10,7 @@
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/miscdevice.h>
+#include <linux/smp_lock.h>
 #include <linux/pm.h>
 
 #include <asm/io.h>
@@ -75,6 +76,7 @@ static inline void apc_free(void)
 
 static int apc_open(struct inode *inode, struct file *f)
 {
+        cycle_kernel_lock();
         return 0;
 }
 
diff --git a/arch/sparc64/kernel/time.c b/arch/sparc64/kernel/time.c
index e5d238970c7e..bedc4c159b1c 100644
--- a/arch/sparc64/kernel/time.c
+++ b/arch/sparc64/kernel/time.c
@@ -11,6 +11,7 @@
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/sched.h>
+#include <linux/smp_lock.h>
 #include <linux/kernel.h>
 #include <linux/param.h>
 #include <linux/string.h>
@@ -1659,10 +1660,14 @@ static int mini_rtc_ioctl(struct inode *inode, struct file *file,
 
 static int mini_rtc_open(struct inode *inode, struct file *file)
 {
-        if (mini_rtc_status & RTC_IS_OPEN)
+        lock_kernel();
+        if (mini_rtc_status & RTC_IS_OPEN) {
+                unlock_kernel();
                 return -EBUSY;
+        }
 
         mini_rtc_status |= RTC_IS_OPEN;
+        unlock_kernel();
 
         return 0;
 }
diff --git a/arch/um/drivers/harddog_kern.c b/arch/um/drivers/harddog_kern.c
index a9ad4bd6d953..d332503fa1be 100644
--- a/arch/um/drivers/harddog_kern.c
+++ b/arch/um/drivers/harddog_kern.c
@@ -66,6 +66,7 @@ static int harddog_open(struct inode *inode, struct file *file)
         int err = -EBUSY;
         char *sock = NULL;
 
+        lock_kernel();
         spin_lock(&lock);
         if(timer_alive)
                 goto err;
@@ -82,9 +83,11 @@ static int harddog_open(struct inode *inode, struct file *file)
 
         timer_alive = 1;
         spin_unlock(&lock);
+        unlock_kernel();
         return nonseekable_open(inode, file);
 err:
         spin_unlock(&lock);
+        unlock_kernel();
         return err;
 }
 
diff --git a/arch/um/drivers/mmapper_kern.c b/arch/um/drivers/mmapper_kern.c
index 67b2f55a602f..eb240323c40a 100644
--- a/arch/um/drivers/mmapper_kern.c
+++ b/arch/um/drivers/mmapper_kern.c
@@ -16,6 +16,7 @@
 #include <linux/miscdevice.h>
 #include <linux/module.h>
 #include <linux/mm.h>
+#include <linux/smp_lock.h>
 #include <asm/uaccess.h>
 #include "mem_user.h"
 
@@ -77,6 +78,7 @@ out:
 
 static int mmapper_open(struct inode *inode, struct file *file)
 {
+        cycle_kernel_lock();
         return 0;
 }
 
diff --git a/arch/um/drivers/random.c b/arch/um/drivers/random.c
index 4949044773ba..6eabb7022a2d 100644
--- a/arch/um/drivers/random.c
+++ b/arch/um/drivers/random.c
@@ -7,6 +7,7 @@
  * of the GNU General Public License, incorporated herein by reference.
  */
 #include <linux/sched.h>
+#include <linux/smp_lock.h>
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/interrupt.h>
@@ -33,6 +34,8 @@ static DECLARE_WAIT_QUEUE_HEAD(host_read_wait);
 
 static int rng_dev_open (struct inode *inode, struct file *filp)
 {
+        cycle_kernel_lock();
+
         /* enforce read-only access to this chrdev */
         if ((filp->f_mode & FMODE_READ) == 0)
                 return -EINVAL;
diff --git a/arch/x86/kernel/apm_32.c b/arch/x86/kernel/apm_32.c
index 00e6d1370954..75cb5da4ea0a 100644
--- a/arch/x86/kernel/apm_32.c
+++ b/arch/x86/kernel/apm_32.c
@@ -204,6 +204,7 @@
 #include <linux/module.h>
 
 #include <linux/poll.h>
+#include <linux/smp_lock.h>
 #include <linux/types.h>
 #include <linux/stddef.h>
 #include <linux/timer.h>
@@ -1549,10 +1550,12 @@ static int do_open(struct inode *inode, struct file *filp)
 {
         struct apm_user *as;
 
+        lock_kernel();
         as = kmalloc(sizeof(*as), GFP_KERNEL);
         if (as == NULL) {
                 printk(KERN_ERR "apm: cannot allocate struct of size %d bytes\n",
                        sizeof(*as));
+                       unlock_kernel();
                 return -ENOMEM;
         }
         as->magic = APM_BIOS_MAGIC;
@@ -1574,6 +1577,7 @@ static int do_open(struct inode *inode, struct file *filp)
         user_list = as;
         spin_unlock(&user_list_lock);
         filp->private_data = as;
+        unlock_kernel();
         return 0;
 }
 
diff --git a/arch/x86/kernel/cpu/mcheck/mce_64.c b/arch/x86/kernel/cpu/mcheck/mce_64.c
index 501ca1cea27d..987410745182 100644
--- a/arch/x86/kernel/cpu/mcheck/mce_64.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_64.c
@@ -9,6 +9,7 @@
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
+#include <linux/smp_lock.h>
 #include <linux/string.h>
 #include <linux/rcupdate.h>
 #include <linux/kallsyms.h>
@@ -532,10 +533,12 @@ static int open_exclu;	/* already open exclusive? */
 
 static int mce_open(struct inode *inode, struct file *file)
 {
+        lock_kernel();
         spin_lock(&mce_state_lock);
 
         if (open_exclu || (open_count && (file->f_flags & O_EXCL))) {
                 spin_unlock(&mce_state_lock);
+                unlock_kernel();
                 return -EBUSY;
         }
 
@@ -544,6 +547,7 @@ static int mce_open(struct inode *inode, struct file *file)
         open_count++;
 
         spin_unlock(&mce_state_lock);
+        unlock_kernel();
 
         return nonseekable_open(inode, file);
 }
diff --git a/arch/x86/kernel/cpuid.c b/arch/x86/kernel/cpuid.c
index daff52a62248..71f1c2654bec 100644
--- a/arch/x86/kernel/cpuid.c
+++ b/arch/x86/kernel/cpuid.c
@@ -33,6 +33,7 @@
 #include <linux/init.h>
 #include <linux/poll.h>
 #include <linux/smp.h>
+#include <linux/smp_lock.h>
 #include <linux/major.h>
 #include <linux/fs.h>
 #include <linux/smp_lock.h>
@@ -107,15 +108,23 @@ static ssize_t cpuid_read(struct file *file, char __user *buf,
 
 static int cpuid_open(struct inode *inode, struct file *file)
 {
-        unsigned int cpu = iminor(file->f_path.dentry->d_inode);
-        struct cpuinfo_x86 *c = &cpu_data(cpu);
-
-        if (cpu >= NR_CPUS || !cpu_online(cpu))
-                return -ENXIO;  /* No such CPU */
+        unsigned int cpu;
+        struct cpuinfo_x86 *c;
+        int ret = 0;
+        
+        lock_kernel();
+
+        cpu = iminor(file->f_path.dentry->d_inode);
+        if (cpu >= NR_CPUS || !cpu_online(cpu)) {
+                ret = -ENXIO;   /* No such CPU */
+                goto out;
+        }
+        c = &cpu_data(cpu);
         if (c->cpuid_level < 0)
-                return -EIO;    /* CPUID not supported */
-
-        return 0;
+                ret = -EIO;     /* CPUID not supported */
+out:
+        unlock_kernel();
+        return ret;
 }
 
 /*
diff --git a/arch/x86/kernel/microcode.c b/arch/x86/kernel/microcode.c
index 9758fea87c5b..f47ba8156f3e 100644
--- a/arch/x86/kernel/microcode.c
+++ b/arch/x86/kernel/microcode.c
@@ -76,6 +76,7 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/sched.h>
+#include <linux/smp_lock.h>
 #include <linux/cpumask.h>
 #include <linux/module.h>
 #include <linux/slab.h>
@@ -423,6 +424,7 @@ out:
 
 static int microcode_open (struct inode *unused1, struct file *unused2)
 {
+        cycle_kernel_lock();
         return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
 }
 
diff --git a/arch/x86/kernel/msr.c b/arch/x86/kernel/msr.c
index 1f3abe048e93..a153b3905f60 100644
--- a/arch/x86/kernel/msr.c
+++ b/arch/x86/kernel/msr.c
@@ -117,12 +117,20 @@ static int msr_open(struct inode *inode, struct file *file)
 {
         unsigned int cpu = iminor(file->f_path.dentry->d_inode);
         struct cpuinfo_x86 *c = &cpu_data(cpu);
+        int ret = 0;
 
-        if (cpu >= NR_CPUS || !cpu_online(cpu))
-                return -ENXIO;  /* No such CPU */
-        if (!cpu_has(c, X86_FEATURE_MSR))
-                return -EIO;    /* MSR not supported */
+        lock_kernel();
+        cpu = iminor(file->f_path.dentry->d_inode);
 
+        if (cpu >= NR_CPUS || !cpu_online(cpu)) {
+                ret = -ENXIO;   /* No such CPU */
+                goto out;
+        }
+        c = &cpu_data(cpu);
+        if (!cpu_has(c, X86_FEATURE_MSR))
+                ret = -EIO;     /* MSR not supported */
+out:
+        unlock_kernel();
         return 0;
 }