diff options
author | Linus Torvalds <torvalds@linux-foundation.org> | 2010-10-22 13:43:11 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@linux-foundation.org> | 2010-10-22 13:43:11 -0400 |
commit | 5704e44d283e907623e3775c1262f206a2c48cf3 (patch) | |
tree | 0a981b24173e90854e7b7d812b35859e1e5f0174 | |
parent | 91151240ed8e97cc4457dae4094153c2744f1eb8 (diff) | |
parent | 6de5bd128d381ad88ac6d419a5e597048eb468cf (diff) |
Merge branch 'config' of git://git.kernel.org/pub/scm/linux/kernel/git/arnd/bkl
* 'config' of git://git.kernel.org/pub/scm/linux/kernel/git/arnd/bkl:
BKL: introduce CONFIG_BKL.
dabusb: remove the BKL
sunrpc: remove the big kernel lock
init/main.c: remove BKL notations
blktrace: remove the big kernel lock
rtmutex-tester: make it build without BKL
dvb-core: kill the big kernel lock
dvb/bt8xx: kill the big kernel lock
tlclk: remove big kernel lock
fix rawctl compat ioctls breakage on amd64 and itanic
uml: kill big kernel lock
parisc: remove big kernel lock
cris: autoconvert trivial BKL users
alpha: kill big kernel lock
isapnp: BKL removal
s390/block: kill the big kernel lock
hpet: kill BKL, add compat_ioctl
53 files changed, 347 insertions, 402 deletions
diff --git a/arch/cris/arch-v10/drivers/ds1302.c b/arch/cris/arch-v10/drivers/ds1302.c index 884275629ef7..4b92ad08b0ff 100644 --- a/arch/cris/arch-v10/drivers/ds1302.c +++ b/arch/cris/arch-v10/drivers/ds1302.c | |||
@@ -19,7 +19,7 @@ | |||
19 | #include <linux/module.h> | 19 | #include <linux/module.h> |
20 | #include <linux/miscdevice.h> | 20 | #include <linux/miscdevice.h> |
21 | #include <linux/delay.h> | 21 | #include <linux/delay.h> |
22 | #include <linux/smp_lock.h> | 22 | #include <linux/mutex.h> |
23 | #include <linux/bcd.h> | 23 | #include <linux/bcd.h> |
24 | #include <linux/capability.h> | 24 | #include <linux/capability.h> |
25 | 25 | ||
@@ -34,6 +34,7 @@ | |||
34 | 34 | ||
35 | #define RTC_MAJOR_NR 121 /* local major, change later */ | 35 | #define RTC_MAJOR_NR 121 /* local major, change later */ |
36 | 36 | ||
37 | static DEFINE_MUTEX(ds1302_mutex); | ||
37 | static const char ds1302_name[] = "ds1302"; | 38 | static const char ds1302_name[] = "ds1302"; |
38 | 39 | ||
39 | /* The DS1302 might be connected to different bits on different products. | 40 | /* The DS1302 might be connected to different bits on different products. |
@@ -357,9 +358,9 @@ static long rtc_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned lon | |||
357 | { | 358 | { |
358 | int ret; | 359 | int ret; |
359 | 360 | ||
360 | lock_kernel(); | 361 | mutex_lock(&ds1302_mutex); |
361 | ret = rtc_ioctl(file, cmd, arg); | 362 | ret = rtc_ioctl(file, cmd, arg); |
362 | unlock_kernel(); | 363 | mutex_unlock(&ds1302_mutex); |
363 | 364 | ||
364 | return ret; | 365 | return ret; |
365 | } | 366 | } |
diff --git a/arch/cris/arch-v10/drivers/pcf8563.c b/arch/cris/arch-v10/drivers/pcf8563.c index 7dcb1f85f42b..2f1ddedca2bd 100644 --- a/arch/cris/arch-v10/drivers/pcf8563.c +++ b/arch/cris/arch-v10/drivers/pcf8563.c | |||
@@ -27,7 +27,6 @@ | |||
27 | #include <linux/delay.h> | 27 | #include <linux/delay.h> |
28 | #include <linux/bcd.h> | 28 | #include <linux/bcd.h> |
29 | #include <linux/mutex.h> | 29 | #include <linux/mutex.h> |
30 | #include <linux/smp_lock.h> | ||
31 | 30 | ||
32 | #include <asm/uaccess.h> | 31 | #include <asm/uaccess.h> |
33 | #include <asm/system.h> | 32 | #include <asm/system.h> |
@@ -49,6 +48,7 @@ | |||
49 | #define rtc_read(x) i2c_readreg(RTC_I2C_READ, x) | 48 | #define rtc_read(x) i2c_readreg(RTC_I2C_READ, x) |
50 | #define rtc_write(x,y) i2c_writereg(RTC_I2C_WRITE, x, y) | 49 | #define rtc_write(x,y) i2c_writereg(RTC_I2C_WRITE, x, y) |
51 | 50 | ||
51 | static DEFINE_MUTEX(pcf8563_mutex); | ||
52 | static DEFINE_MUTEX(rtc_lock); /* Protect state etc */ | 52 | static DEFINE_MUTEX(rtc_lock); /* Protect state etc */ |
53 | 53 | ||
54 | static const unsigned char days_in_month[] = | 54 | static const unsigned char days_in_month[] = |
@@ -343,9 +343,9 @@ static long pcf8563_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned | |||
343 | { | 343 | { |
344 | int ret; | 344 | int ret; |
345 | 345 | ||
346 | lock_kernel(); | 346 | mutex_lock(&pcf8563_mutex); |
347 | return pcf8563_ioctl(filp, cmd, arg); | 347 | return pcf8563_ioctl(filp, cmd, arg); |
348 | unlock_kernel(); | 348 | mutex_unlock(&pcf8563_mutex); |
349 | 349 | ||
350 | return ret; | 350 | return ret; |
351 | } | 351 | } |
diff --git a/arch/cris/arch-v10/drivers/sync_serial.c b/arch/cris/arch-v10/drivers/sync_serial.c index ee2dd4323daf..3d9fa074a941 100644 --- a/arch/cris/arch-v10/drivers/sync_serial.c +++ b/arch/cris/arch-v10/drivers/sync_serial.c | |||
@@ -20,7 +20,7 @@ | |||
20 | #include <linux/interrupt.h> | 20 | #include <linux/interrupt.h> |
21 | #include <linux/poll.h> | 21 | #include <linux/poll.h> |
22 | #include <linux/init.h> | 22 | #include <linux/init.h> |
23 | #include <linux/smp_lock.h> | 23 | #include <linux/mutex.h> |
24 | #include <linux/timer.h> | 24 | #include <linux/timer.h> |
25 | #include <asm/irq.h> | 25 | #include <asm/irq.h> |
26 | #include <asm/dma.h> | 26 | #include <asm/dma.h> |
@@ -149,6 +149,7 @@ struct sync_port { | |||
149 | }; | 149 | }; |
150 | 150 | ||
151 | 151 | ||
152 | static DEFINE_MUTEX(sync_serial_mutex); | ||
152 | static int etrax_sync_serial_init(void); | 153 | static int etrax_sync_serial_init(void); |
153 | static void initialize_port(int portnbr); | 154 | static void initialize_port(int portnbr); |
154 | static inline int sync_data_avail(struct sync_port *port); | 155 | static inline int sync_data_avail(struct sync_port *port); |
@@ -445,7 +446,7 @@ static int sync_serial_open(struct inode *inode, struct file *file) | |||
445 | int mode; | 446 | int mode; |
446 | int err = -EBUSY; | 447 | int err = -EBUSY; |
447 | 448 | ||
448 | lock_kernel(); | 449 | mutex_lock(&sync_serial_mutex); |
449 | DEBUG(printk(KERN_DEBUG "Open sync serial port %d\n", dev)); | 450 | DEBUG(printk(KERN_DEBUG "Open sync serial port %d\n", dev)); |
450 | 451 | ||
451 | if (dev < 0 || dev >= NUMBER_OF_PORTS || !ports[dev].enabled) { | 452 | if (dev < 0 || dev >= NUMBER_OF_PORTS || !ports[dev].enabled) { |
@@ -626,7 +627,7 @@ static int sync_serial_open(struct inode *inode, struct file *file) | |||
626 | ret = 0; | 627 | ret = 0; |
627 | 628 | ||
628 | out: | 629 | out: |
629 | unlock_kernel(); | 630 | mutex_unlock(&sync_serial_mutex); |
630 | return ret; | 631 | return ret; |
631 | } | 632 | } |
632 | 633 | ||
@@ -961,9 +962,9 @@ static long sync_serial_ioctl(struct file *file, | |||
961 | { | 962 | { |
962 | long ret; | 963 | long ret; |
963 | 964 | ||
964 | lock_kernel(); | 965 | mutex_lock(&sync_serial_mutex); |
965 | ret = sync_serial_ioctl_unlocked(file, cmd, arg); | 966 | ret = sync_serial_ioctl_unlocked(file, cmd, arg); |
966 | unlock_kernel(); | 967 | mutex_unlock(&sync_serial_mutex); |
967 | 968 | ||
968 | return ret; | 969 | return ret; |
969 | } | 970 | } |
diff --git a/arch/cris/arch-v32/drivers/cryptocop.c b/arch/cris/arch-v32/drivers/cryptocop.c index b07646a30509..0973d5a2780f 100644 --- a/arch/cris/arch-v32/drivers/cryptocop.c +++ b/arch/cris/arch-v32/drivers/cryptocop.c | |||
@@ -3139,9 +3139,9 @@ cryptocop_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) | |||
3139 | struct inode *inode = file->f_path.dentry->d_inode; | 3139 | struct inode *inode = file->f_path.dentry->d_inode; |
3140 | long ret; | 3140 | long ret; |
3141 | 3141 | ||
3142 | lock_kernel(); | 3142 | mutex_lock(&cryptocop_mutex); |
3143 | ret = cryptocop_ioctl_unlocked(inode, filp, cmd, arg); | 3143 | ret = cryptocop_ioctl_unlocked(inode, filp, cmd, arg); |
3144 | unlock_kernel(); | 3144 | mutex_unlock(&cryptocop_mutex); |
3145 | 3145 | ||
3146 | return ret; | 3146 | return ret; |
3147 | } | 3147 | } |
diff --git a/arch/cris/arch-v32/drivers/mach-a3/gpio.c b/arch/cris/arch-v32/drivers/mach-a3/gpio.c index 2dcd27adbad4..50d1885c4794 100644 --- a/arch/cris/arch-v32/drivers/mach-a3/gpio.c +++ b/arch/cris/arch-v32/drivers/mach-a3/gpio.c | |||
@@ -23,7 +23,7 @@ | |||
23 | #include <linux/init.h> | 23 | #include <linux/init.h> |
24 | #include <linux/interrupt.h> | 24 | #include <linux/interrupt.h> |
25 | #include <linux/spinlock.h> | 25 | #include <linux/spinlock.h> |
26 | #include <linux/smp_lock.h> | 26 | #include <linux/mutex.h> |
27 | 27 | ||
28 | #include <asm/etraxgpio.h> | 28 | #include <asm/etraxgpio.h> |
29 | #include <hwregs/reg_map.h> | 29 | #include <hwregs/reg_map.h> |
@@ -66,6 +66,7 @@ static int dp_cnt; | |||
66 | #define DP(x) | 66 | #define DP(x) |
67 | #endif | 67 | #endif |
68 | 68 | ||
69 | static DEFINE_MUTEX(gpio_mutex); | ||
69 | static char gpio_name[] = "etrax gpio"; | 70 | static char gpio_name[] = "etrax gpio"; |
70 | 71 | ||
71 | #ifdef CONFIG_ETRAX_VIRTUAL_GPIO | 72 | #ifdef CONFIG_ETRAX_VIRTUAL_GPIO |
@@ -391,7 +392,7 @@ static int gpio_open(struct inode *inode, struct file *filp) | |||
391 | if (!priv) | 392 | if (!priv) |
392 | return -ENOMEM; | 393 | return -ENOMEM; |
393 | 394 | ||
394 | lock_kernel(); | 395 | mutex_lock(&gpio_mutex); |
395 | memset(priv, 0, sizeof(*priv)); | 396 | memset(priv, 0, sizeof(*priv)); |
396 | 397 | ||
397 | priv->minor = p; | 398 | priv->minor = p; |
@@ -414,7 +415,7 @@ static int gpio_open(struct inode *inode, struct file *filp) | |||
414 | spin_unlock_irq(&gpio_lock); | 415 | spin_unlock_irq(&gpio_lock); |
415 | } | 416 | } |
416 | 417 | ||
417 | unlock_kernel(); | 418 | mutex_unlock(&gpio_mutex); |
418 | return 0; | 419 | return 0; |
419 | } | 420 | } |
420 | 421 | ||
@@ -667,9 +668,9 @@ static long gpio_ioctl(struct file *file, unsigned int cmd, unsigned long arg) | |||
667 | { | 668 | { |
668 | long ret; | 669 | long ret; |
669 | 670 | ||
670 | lock_kernel(); | 671 | mutex_lock(&gpio_mutex); |
671 | ret = gpio_ioctl_unlocked(file, cmd, arg); | 672 | ret = gpio_ioctl_unlocked(file, cmd, arg); |
672 | unlock_kernel(); | 673 | mutex_unlock(&gpio_mutex); |
673 | 674 | ||
674 | return ret; | 675 | return ret; |
675 | } | 676 | } |
diff --git a/arch/cris/arch-v32/drivers/mach-fs/gpio.c b/arch/cris/arch-v32/drivers/mach-fs/gpio.c index 5ec8a7d4e7d7..de8dca0550f2 100644 --- a/arch/cris/arch-v32/drivers/mach-fs/gpio.c +++ b/arch/cris/arch-v32/drivers/mach-fs/gpio.c | |||
@@ -22,7 +22,7 @@ | |||
22 | #include <linux/init.h> | 22 | #include <linux/init.h> |
23 | #include <linux/interrupt.h> | 23 | #include <linux/interrupt.h> |
24 | #include <linux/spinlock.h> | 24 | #include <linux/spinlock.h> |
25 | #include <linux/smp_lock.h> | 25 | #include <linux/mutex.h> |
26 | 26 | ||
27 | #include <asm/etraxgpio.h> | 27 | #include <asm/etraxgpio.h> |
28 | #include <hwregs/reg_map.h> | 28 | #include <hwregs/reg_map.h> |
@@ -64,6 +64,7 @@ static int dp_cnt; | |||
64 | #define DP(x) | 64 | #define DP(x) |
65 | #endif | 65 | #endif |
66 | 66 | ||
67 | static DEFINE_MUTEX(gpio_mutex); | ||
67 | static char gpio_name[] = "etrax gpio"; | 68 | static char gpio_name[] = "etrax gpio"; |
68 | 69 | ||
69 | #if 0 | 70 | #if 0 |
@@ -429,7 +430,7 @@ gpio_open(struct inode *inode, struct file *filp) | |||
429 | if (!priv) | 430 | if (!priv) |
430 | return -ENOMEM; | 431 | return -ENOMEM; |
431 | 432 | ||
432 | lock_kernel(); | 433 | mutex_lock(&gpio_mutex); |
433 | memset(priv, 0, sizeof(*priv)); | 434 | memset(priv, 0, sizeof(*priv)); |
434 | 435 | ||
435 | priv->minor = p; | 436 | priv->minor = p; |
@@ -450,7 +451,7 @@ gpio_open(struct inode *inode, struct file *filp) | |||
450 | alarmlist = priv; | 451 | alarmlist = priv; |
451 | spin_unlock_irq(&alarm_lock); | 452 | spin_unlock_irq(&alarm_lock); |
452 | 453 | ||
453 | unlock_kernel(); | 454 | mutex_unlock(&gpio_mutex); |
454 | return 0; | 455 | return 0; |
455 | } | 456 | } |
456 | 457 | ||
@@ -708,9 +709,9 @@ static long gpio_ioctl(struct file *file, unsigned int cmd, unsigned long arg) | |||
708 | { | 709 | { |
709 | long ret; | 710 | long ret; |
710 | 711 | ||
711 | lock_kernel(); | 712 | mutex_lock(&gpio_mutex); |
712 | ret = gpio_ioctl_unlocked(file, cmd, arg); | 713 | ret = gpio_ioctl_unlocked(file, cmd, arg); |
713 | unlock_kernel(); | 714 | mutex_unlock(&gpio_mutex); |
714 | 715 | ||
715 | return ret; | 716 | return ret; |
716 | } | 717 | } |
diff --git a/arch/cris/arch-v32/drivers/pcf8563.c b/arch/cris/arch-v32/drivers/pcf8563.c index bef6eb53b153..bdcac9dec5cb 100644 --- a/arch/cris/arch-v32/drivers/pcf8563.c +++ b/arch/cris/arch-v32/drivers/pcf8563.c | |||
@@ -24,7 +24,6 @@ | |||
24 | #include <linux/init.h> | 24 | #include <linux/init.h> |
25 | #include <linux/fs.h> | 25 | #include <linux/fs.h> |
26 | #include <linux/ioctl.h> | 26 | #include <linux/ioctl.h> |
27 | #include <linux/smp_lock.h> | ||
28 | #include <linux/delay.h> | 27 | #include <linux/delay.h> |
29 | #include <linux/bcd.h> | 28 | #include <linux/bcd.h> |
30 | #include <linux/mutex.h> | 29 | #include <linux/mutex.h> |
@@ -45,6 +44,7 @@ | |||
45 | #define rtc_read(x) i2c_readreg(RTC_I2C_READ, x) | 44 | #define rtc_read(x) i2c_readreg(RTC_I2C_READ, x) |
46 | #define rtc_write(x,y) i2c_writereg(RTC_I2C_WRITE, x, y) | 45 | #define rtc_write(x,y) i2c_writereg(RTC_I2C_WRITE, x, y) |
47 | 46 | ||
47 | static DEFINE_MUTEX(pcf8563_mutex); | ||
48 | static DEFINE_MUTEX(rtc_lock); /* Protect state etc */ | 48 | static DEFINE_MUTEX(rtc_lock); /* Protect state etc */ |
49 | 49 | ||
50 | static const unsigned char days_in_month[] = | 50 | static const unsigned char days_in_month[] = |
@@ -339,9 +339,9 @@ static long pcf8563_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned | |||
339 | { | 339 | { |
340 | int ret; | 340 | int ret; |
341 | 341 | ||
342 | lock_kernel(); | 342 | mutex_lock(&pcf8563_mutex); |
343 | return pcf8563_ioctl(filp, cmd, arg); | 343 | return pcf8563_ioctl(filp, cmd, arg); |
344 | unlock_kernel(); | 344 | mutex_unlock(&pcf8563_mutex); |
345 | 345 | ||
346 | return ret; | 346 | return ret; |
347 | } | 347 | } |
diff --git a/arch/cris/arch-v32/drivers/sync_serial.c b/arch/cris/arch-v32/drivers/sync_serial.c index ca248f3adb80..a01ae9f3b814 100644 --- a/arch/cris/arch-v32/drivers/sync_serial.c +++ b/arch/cris/arch-v32/drivers/sync_serial.c | |||
@@ -13,7 +13,7 @@ | |||
13 | #include <linux/errno.h> | 13 | #include <linux/errno.h> |
14 | #include <linux/major.h> | 14 | #include <linux/major.h> |
15 | #include <linux/sched.h> | 15 | #include <linux/sched.h> |
16 | #include <linux/smp_lock.h> | 16 | #include <linux/mutex.h> |
17 | #include <linux/interrupt.h> | 17 | #include <linux/interrupt.h> |
18 | #include <linux/poll.h> | 18 | #include <linux/poll.h> |
19 | #include <linux/init.h> | 19 | #include <linux/init.h> |
@@ -145,6 +145,7 @@ typedef struct sync_port | |||
145 | spinlock_t lock; | 145 | spinlock_t lock; |
146 | } sync_port; | 146 | } sync_port; |
147 | 147 | ||
148 | static DEFINE_MUTEX(sync_serial_mutex); | ||
148 | static int etrax_sync_serial_init(void); | 149 | static int etrax_sync_serial_init(void); |
149 | static void initialize_port(int portnbr); | 150 | static void initialize_port(int portnbr); |
150 | static inline int sync_data_avail(struct sync_port *port); | 151 | static inline int sync_data_avail(struct sync_port *port); |
@@ -434,7 +435,7 @@ static int sync_serial_open(struct inode *inode, struct file *file) | |||
434 | reg_dma_rw_cfg cfg = {.en = regk_dma_yes}; | 435 | reg_dma_rw_cfg cfg = {.en = regk_dma_yes}; |
435 | reg_dma_rw_intr_mask intr_mask = {.data = regk_dma_yes}; | 436 | reg_dma_rw_intr_mask intr_mask = {.data = regk_dma_yes}; |
436 | 437 | ||
437 | lock_kernel(); | 438 | mutex_lock(&sync_serial_mutex); |
438 | DEBUG(printk(KERN_DEBUG "Open sync serial port %d\n", dev)); | 439 | DEBUG(printk(KERN_DEBUG "Open sync serial port %d\n", dev)); |
439 | 440 | ||
440 | if (dev < 0 || dev >= NBR_PORTS || !ports[dev].enabled) | 441 | if (dev < 0 || dev >= NBR_PORTS || !ports[dev].enabled) |
@@ -583,7 +584,7 @@ static int sync_serial_open(struct inode *inode, struct file *file) | |||
583 | port->busy++; | 584 | port->busy++; |
584 | ret = 0; | 585 | ret = 0; |
585 | out: | 586 | out: |
586 | unlock_kernel(); | 587 | mutex_unlock(&sync_serial_mutex); |
587 | return ret; | 588 | return ret; |
588 | } | 589 | } |
589 | 590 | ||
@@ -966,9 +967,9 @@ static long sync_serial_ioctl(struct file *file, | |||
966 | { | 967 | { |
967 | long ret; | 968 | long ret; |
968 | 969 | ||
969 | lock_kernel(); | 970 | mutex_lock(&sync_serial_mutex); |
970 | ret = sync_serial_ioctl_unlocked(file, cmd, arg); | 971 | ret = sync_serial_ioctl_unlocked(file, cmd, arg); |
971 | unlock_kernel(); | 972 | mutex_unlock(&sync_serial_mutex); |
972 | 973 | ||
973 | return ret; | 974 | return ret; |
974 | } | 975 | } |
diff --git a/arch/parisc/kernel/perf.c b/arch/parisc/kernel/perf.c index f9f6783e4bdd..ba0c053e25ae 100644 --- a/arch/parisc/kernel/perf.c +++ b/arch/parisc/kernel/perf.c | |||
@@ -46,7 +46,6 @@ | |||
46 | #include <linux/init.h> | 46 | #include <linux/init.h> |
47 | #include <linux/proc_fs.h> | 47 | #include <linux/proc_fs.h> |
48 | #include <linux/miscdevice.h> | 48 | #include <linux/miscdevice.h> |
49 | #include <linux/smp_lock.h> | ||
50 | #include <linux/spinlock.h> | 49 | #include <linux/spinlock.h> |
51 | 50 | ||
52 | #include <asm/uaccess.h> | 51 | #include <asm/uaccess.h> |
@@ -261,16 +260,13 @@ printk("Preparing to start counters\n"); | |||
261 | */ | 260 | */ |
262 | static int perf_open(struct inode *inode, struct file *file) | 261 | static int perf_open(struct inode *inode, struct file *file) |
263 | { | 262 | { |
264 | lock_kernel(); | ||
265 | spin_lock(&perf_lock); | 263 | spin_lock(&perf_lock); |
266 | if (perf_enabled) { | 264 | if (perf_enabled) { |
267 | spin_unlock(&perf_lock); | 265 | spin_unlock(&perf_lock); |
268 | unlock_kernel(); | ||
269 | return -EBUSY; | 266 | return -EBUSY; |
270 | } | 267 | } |
271 | perf_enabled = 1; | 268 | perf_enabled = 1; |
272 | spin_unlock(&perf_lock); | 269 | spin_unlock(&perf_lock); |
273 | unlock_kernel(); | ||
274 | 270 | ||
275 | return 0; | 271 | return 0; |
276 | } | 272 | } |
diff --git a/arch/um/drivers/harddog_kern.c b/arch/um/drivers/harddog_kern.c index cfcac1ff4cf2..86036276020f 100644 --- a/arch/um/drivers/harddog_kern.c +++ b/arch/um/drivers/harddog_kern.c | |||
@@ -42,7 +42,7 @@ | |||
42 | #include <linux/miscdevice.h> | 42 | #include <linux/miscdevice.h> |
43 | #include <linux/watchdog.h> | 43 | #include <linux/watchdog.h> |
44 | #include <linux/reboot.h> | 44 | #include <linux/reboot.h> |
45 | #include <linux/smp_lock.h> | 45 | #include <linux/mutex.h> |
46 | #include <linux/init.h> | 46 | #include <linux/init.h> |
47 | #include <linux/spinlock.h> | 47 | #include <linux/spinlock.h> |
48 | #include <asm/uaccess.h> | 48 | #include <asm/uaccess.h> |
@@ -50,6 +50,7 @@ | |||
50 | 50 | ||
51 | MODULE_LICENSE("GPL"); | 51 | MODULE_LICENSE("GPL"); |
52 | 52 | ||
53 | static DEFINE_MUTEX(harddog_mutex); | ||
53 | static DEFINE_SPINLOCK(lock); | 54 | static DEFINE_SPINLOCK(lock); |
54 | static int timer_alive; | 55 | static int timer_alive; |
55 | static int harddog_in_fd = -1; | 56 | static int harddog_in_fd = -1; |
@@ -66,7 +67,7 @@ static int harddog_open(struct inode *inode, struct file *file) | |||
66 | int err = -EBUSY; | 67 | int err = -EBUSY; |
67 | char *sock = NULL; | 68 | char *sock = NULL; |
68 | 69 | ||
69 | lock_kernel(); | 70 | mutex_lock(&harddog_mutex); |
70 | spin_lock(&lock); | 71 | spin_lock(&lock); |
71 | if(timer_alive) | 72 | if(timer_alive) |
72 | goto err; | 73 | goto err; |
@@ -83,11 +84,11 @@ static int harddog_open(struct inode *inode, struct file *file) | |||
83 | 84 | ||
84 | timer_alive = 1; | 85 | timer_alive = 1; |
85 | spin_unlock(&lock); | 86 | spin_unlock(&lock); |
86 | unlock_kernel(); | 87 | mutex_unlock(&harddog_mutex); |
87 | return nonseekable_open(inode, file); | 88 | return nonseekable_open(inode, file); |
88 | err: | 89 | err: |
89 | spin_unlock(&lock); | 90 | spin_unlock(&lock); |
90 | unlock_kernel(); | 91 | mutex_unlock(&harddog_mutex); |
91 | return err; | 92 | return err; |
92 | } | 93 | } |
93 | 94 | ||
@@ -153,9 +154,9 @@ static long harddog_ioctl(struct file *file, | |||
153 | { | 154 | { |
154 | long ret; | 155 | long ret; |
155 | 156 | ||
156 | lock_kernel(); | 157 | mutex_lock(&harddog_mutex); |
157 | ret = harddog_ioctl_unlocked(file, cmd, arg); | 158 | ret = harddog_ioctl_unlocked(file, cmd, arg); |
158 | unlock_kernel(); | 159 | mutex_unlock(&harddog_mutex); |
159 | 160 | ||
160 | return ret; | 161 | return ret; |
161 | } | 162 | } |
diff --git a/arch/um/drivers/hostaudio_kern.c b/arch/um/drivers/hostaudio_kern.c index 63c740a85b4c..f9f6a4e20590 100644 --- a/arch/um/drivers/hostaudio_kern.c +++ b/arch/um/drivers/hostaudio_kern.c | |||
@@ -8,7 +8,7 @@ | |||
8 | #include "linux/slab.h" | 8 | #include "linux/slab.h" |
9 | #include "linux/sound.h" | 9 | #include "linux/sound.h" |
10 | #include "linux/soundcard.h" | 10 | #include "linux/soundcard.h" |
11 | #include "linux/smp_lock.h" | 11 | #include "linux/mutex.h" |
12 | #include "asm/uaccess.h" | 12 | #include "asm/uaccess.h" |
13 | #include "init.h" | 13 | #include "init.h" |
14 | #include "os.h" | 14 | #include "os.h" |
@@ -63,6 +63,8 @@ static int set_mixer(char *name, int *add) | |||
63 | __uml_setup("mixer=", set_mixer, "mixer=<mixer device>\n" MIXER_HELP); | 63 | __uml_setup("mixer=", set_mixer, "mixer=<mixer device>\n" MIXER_HELP); |
64 | #endif | 64 | #endif |
65 | 65 | ||
66 | static DEFINE_MUTEX(hostaudio_mutex); | ||
67 | |||
66 | /* /dev/dsp file operations */ | 68 | /* /dev/dsp file operations */ |
67 | 69 | ||
68 | static ssize_t hostaudio_read(struct file *file, char __user *buffer, | 70 | static ssize_t hostaudio_read(struct file *file, char __user *buffer, |
@@ -198,9 +200,9 @@ static int hostaudio_open(struct inode *inode, struct file *file) | |||
198 | w = 1; | 200 | w = 1; |
199 | 201 | ||
200 | kparam_block_sysfs_write(dsp); | 202 | kparam_block_sysfs_write(dsp); |
201 | lock_kernel(); | 203 | mutex_lock(&hostaudio_mutex); |
202 | ret = os_open_file(dsp, of_set_rw(OPENFLAGS(), r, w), 0); | 204 | ret = os_open_file(dsp, of_set_rw(OPENFLAGS(), r, w), 0); |
203 | unlock_kernel(); | 205 | mutex_unlock(&hostaudio_mutex); |
204 | kparam_unblock_sysfs_write(dsp); | 206 | kparam_unblock_sysfs_write(dsp); |
205 | 207 | ||
206 | if (ret < 0) { | 208 | if (ret < 0) { |
@@ -259,9 +261,9 @@ static int hostmixer_open_mixdev(struct inode *inode, struct file *file) | |||
259 | w = 1; | 261 | w = 1; |
260 | 262 | ||
261 | kparam_block_sysfs_write(mixer); | 263 | kparam_block_sysfs_write(mixer); |
262 | lock_kernel(); | 264 | mutex_lock(&hostaudio_mutex); |
263 | ret = os_open_file(mixer, of_set_rw(OPENFLAGS(), r, w), 0); | 265 | ret = os_open_file(mixer, of_set_rw(OPENFLAGS(), r, w), 0); |
264 | unlock_kernel(); | 266 | mutex_unlock(&hostaudio_mutex); |
265 | kparam_unblock_sysfs_write(mixer); | 267 | kparam_unblock_sysfs_write(mixer); |
266 | 268 | ||
267 | if (ret < 0) { | 269 | if (ret < 0) { |
diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c index 9734994cba1e..ba4a98ba39c0 100644 --- a/arch/um/drivers/ubd_kern.c +++ b/arch/um/drivers/ubd_kern.c | |||
@@ -33,7 +33,7 @@ | |||
33 | #include "linux/mm.h" | 33 | #include "linux/mm.h" |
34 | #include "linux/slab.h" | 34 | #include "linux/slab.h" |
35 | #include "linux/vmalloc.h" | 35 | #include "linux/vmalloc.h" |
36 | #include "linux/smp_lock.h" | 36 | #include "linux/mutex.h" |
37 | #include "linux/blkpg.h" | 37 | #include "linux/blkpg.h" |
38 | #include "linux/genhd.h" | 38 | #include "linux/genhd.h" |
39 | #include "linux/spinlock.h" | 39 | #include "linux/spinlock.h" |
@@ -100,6 +100,7 @@ static inline void ubd_set_bit(__u64 bit, unsigned char *data) | |||
100 | #define DRIVER_NAME "uml-blkdev" | 100 | #define DRIVER_NAME "uml-blkdev" |
101 | 101 | ||
102 | static DEFINE_MUTEX(ubd_lock); | 102 | static DEFINE_MUTEX(ubd_lock); |
103 | static DEFINE_MUTEX(ubd_mutex); /* replaces BKL, might not be needed */ | ||
103 | 104 | ||
104 | static int ubd_open(struct block_device *bdev, fmode_t mode); | 105 | static int ubd_open(struct block_device *bdev, fmode_t mode); |
105 | static int ubd_release(struct gendisk *disk, fmode_t mode); | 106 | static int ubd_release(struct gendisk *disk, fmode_t mode); |
@@ -1101,7 +1102,7 @@ static int ubd_open(struct block_device *bdev, fmode_t mode) | |||
1101 | struct ubd *ubd_dev = disk->private_data; | 1102 | struct ubd *ubd_dev = disk->private_data; |
1102 | int err = 0; | 1103 | int err = 0; |
1103 | 1104 | ||
1104 | lock_kernel(); | 1105 | mutex_lock(&ubd_mutex); |
1105 | if(ubd_dev->count == 0){ | 1106 | if(ubd_dev->count == 0){ |
1106 | err = ubd_open_dev(ubd_dev); | 1107 | err = ubd_open_dev(ubd_dev); |
1107 | if(err){ | 1108 | if(err){ |
@@ -1120,7 +1121,7 @@ static int ubd_open(struct block_device *bdev, fmode_t mode) | |||
1120 | err = -EROFS; | 1121 | err = -EROFS; |
1121 | }*/ | 1122 | }*/ |
1122 | out: | 1123 | out: |
1123 | unlock_kernel(); | 1124 | mutex_unlock(&ubd_mutex); |
1124 | return err; | 1125 | return err; |
1125 | } | 1126 | } |
1126 | 1127 | ||
@@ -1128,10 +1129,10 @@ static int ubd_release(struct gendisk *disk, fmode_t mode) | |||
1128 | { | 1129 | { |
1129 | struct ubd *ubd_dev = disk->private_data; | 1130 | struct ubd *ubd_dev = disk->private_data; |
1130 | 1131 | ||
1131 | lock_kernel(); | 1132 | mutex_lock(&ubd_mutex); |
1132 | if(--ubd_dev->count == 0) | 1133 | if(--ubd_dev->count == 0) |
1133 | ubd_close_dev(ubd_dev); | 1134 | ubd_close_dev(ubd_dev); |
1134 | unlock_kernel(); | 1135 | mutex_unlock(&ubd_mutex); |
1135 | return 0; | 1136 | return 0; |
1136 | } | 1137 | } |
1137 | 1138 | ||
diff --git a/arch/um/kernel/exec.c b/arch/um/kernel/exec.c index 49b5e1eb3262..340268be00b5 100644 --- a/arch/um/kernel/exec.c +++ b/arch/um/kernel/exec.c | |||
@@ -78,13 +78,11 @@ long sys_execve(const char __user *file, const char __user *const __user *argv, | |||
78 | long error; | 78 | long error; |
79 | char *filename; | 79 | char *filename; |
80 | 80 | ||
81 | lock_kernel(); | ||
82 | filename = getname(file); | 81 | filename = getname(file); |
83 | error = PTR_ERR(filename); | 82 | error = PTR_ERR(filename); |
84 | if (IS_ERR(filename)) goto out; | 83 | if (IS_ERR(filename)) goto out; |
85 | error = execve1(filename, argv, env); | 84 | error = execve1(filename, argv, env); |
86 | putname(filename); | 85 | putname(filename); |
87 | out: | 86 | out: |
88 | unlock_kernel(); | ||
89 | return error; | 87 | return error; |
90 | } | 88 | } |
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 @@ | |||
30 | #include <linux/bcd.h> | 30 | #include <linux/bcd.h> |
31 | #include <linux/seq_file.h> | 31 | #include <linux/seq_file.h> |
32 | #include <linux/bitops.h> | 32 | #include <linux/bitops.h> |
33 | #include <linux/compat.h> | ||
33 | #include <linux/clocksource.h> | 34 | #include <linux/clocksource.h> |
34 | #include <linux/slab.h> | 35 | #include <linux/slab.h> |
35 | 36 | ||
@@ -67,6 +68,7 @@ | |||
67 | #define read_counter(MC) readl(MC) | 68 | #define read_counter(MC) readl(MC) |
68 | #endif | 69 | #endif |
69 | 70 | ||
71 | static DEFINE_MUTEX(hpet_mutex); /* replaces BKL */ | ||
70 | static u32 hpet_nhpet, hpet_max_freq = HPET_USER_FREQ; | 72 | static u32 hpet_nhpet, hpet_max_freq = HPET_USER_FREQ; |
71 | 73 | ||
72 | /* This clocksource driver currently only works on ia64 */ | 74 | /* This clocksource driver currently only works on ia64 */ |
@@ -250,7 +252,7 @@ static int hpet_open(struct inode *inode, struct file *file) | |||
250 | if (file->f_mode & FMODE_WRITE) | 252 | if (file->f_mode & FMODE_WRITE) |
251 | return -EINVAL; | 253 | return -EINVAL; |
252 | 254 | ||
253 | lock_kernel(); | 255 | mutex_lock(&hpet_mutex); |
254 | spin_lock_irq(&hpet_lock); | 256 | spin_lock_irq(&hpet_lock); |
255 | 257 | ||
256 | for (devp = NULL, hpetp = hpets; hpetp && !devp; hpetp = hpetp->hp_next) | 258 | 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) | |||
264 | 266 | ||
265 | if (!devp) { | 267 | if (!devp) { |
266 | spin_unlock_irq(&hpet_lock); | 268 | spin_unlock_irq(&hpet_lock); |
267 | unlock_kernel(); | 269 | mutex_unlock(&hpet_mutex); |
268 | return -EBUSY; | 270 | return -EBUSY; |
269 | } | 271 | } |
270 | 272 | ||
@@ -272,7 +274,7 @@ static int hpet_open(struct inode *inode, struct file *file) | |||
272 | devp->hd_irqdata = 0; | 274 | devp->hd_irqdata = 0; |
273 | devp->hd_flags |= HPET_OPEN; | 275 | devp->hd_flags |= HPET_OPEN; |
274 | spin_unlock_irq(&hpet_lock); | 276 | spin_unlock_irq(&hpet_lock); |
275 | unlock_kernel(); | 277 | mutex_unlock(&hpet_mutex); |
276 | 278 | ||
277 | hpet_timer_set_irq(devp); | 279 | hpet_timer_set_irq(devp); |
278 | 280 | ||
@@ -429,22 +431,6 @@ static int hpet_release(struct inode *inode, struct file *file) | |||
429 | return 0; | 431 | return 0; |
430 | } | 432 | } |
431 | 433 | ||
432 | static int hpet_ioctl_common(struct hpet_dev *, int, unsigned long, int); | ||
433 | |||
434 | static long hpet_ioctl(struct file *file, unsigned int cmd, | ||
435 | unsigned long arg) | ||
436 | { | ||
437 | struct hpet_dev *devp; | ||
438 | int ret; | ||
439 | |||
440 | devp = file->private_data; | ||
441 | lock_kernel(); | ||
442 | ret = hpet_ioctl_common(devp, cmd, arg, 0); | ||
443 | unlock_kernel(); | ||
444 | |||
445 | return ret; | ||
446 | } | ||
447 | |||
448 | static int hpet_ioctl_ieon(struct hpet_dev *devp) | 434 | static int hpet_ioctl_ieon(struct hpet_dev *devp) |
449 | { | 435 | { |
450 | struct hpet_timer __iomem *timer; | 436 | struct hpet_timer __iomem *timer; |
@@ -553,7 +539,8 @@ static inline unsigned long hpet_time_div(struct hpets *hpets, | |||
553 | } | 539 | } |
554 | 540 | ||
555 | static int | 541 | static int |
556 | hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel) | 542 | hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, |
543 | struct hpet_info *info) | ||
557 | { | 544 | { |
558 | struct hpet_timer __iomem *timer; | 545 | struct hpet_timer __iomem *timer; |
559 | struct hpet __iomem *hpet; | 546 | struct hpet __iomem *hpet; |
@@ -594,23 +581,15 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel) | |||
594 | break; | 581 | break; |
595 | case HPET_INFO: | 582 | case HPET_INFO: |
596 | { | 583 | { |
597 | struct hpet_info info; | ||
598 | |||
599 | if (devp->hd_ireqfreq) | 584 | if (devp->hd_ireqfreq) |
600 | info.hi_ireqfreq = | 585 | info->hi_ireqfreq = |
601 | hpet_time_div(hpetp, devp->hd_ireqfreq); | 586 | hpet_time_div(hpetp, devp->hd_ireqfreq); |
602 | else | 587 | else |
603 | info.hi_ireqfreq = 0; | 588 | info->hi_ireqfreq = 0; |
604 | info.hi_flags = | 589 | info->hi_flags = |
605 | readq(&timer->hpet_config) & Tn_PER_INT_CAP_MASK; | 590 | readq(&timer->hpet_config) & Tn_PER_INT_CAP_MASK; |
606 | info.hi_hpet = hpetp->hp_which; | 591 | info->hi_hpet = hpetp->hp_which; |
607 | info.hi_timer = devp - hpetp->hp_dev; | 592 | info->hi_timer = devp - hpetp->hp_dev; |
608 | if (kernel) | ||
609 | memcpy((void *)arg, &info, sizeof(info)); | ||
610 | else | ||
611 | if (copy_to_user((void __user *)arg, &info, | ||
612 | sizeof(info))) | ||
613 | err = -EFAULT; | ||
614 | break; | 593 | break; |
615 | } | 594 | } |
616 | case HPET_EPI: | 595 | case HPET_EPI: |
@@ -636,7 +615,7 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel) | |||
636 | devp->hd_flags &= ~HPET_PERIODIC; | 615 | devp->hd_flags &= ~HPET_PERIODIC; |
637 | break; | 616 | break; |
638 | case HPET_IRQFREQ: | 617 | case HPET_IRQFREQ: |
639 | if (!kernel && (arg > hpet_max_freq) && | 618 | if ((arg > hpet_max_freq) && |
640 | !capable(CAP_SYS_RESOURCE)) { | 619 | !capable(CAP_SYS_RESOURCE)) { |
641 | err = -EACCES; | 620 | err = -EACCES; |
642 | break; | 621 | break; |
@@ -653,12 +632,63 @@ hpet_ioctl_common(struct hpet_dev *devp, int cmd, unsigned long arg, int kernel) | |||
653 | return err; | 632 | return err; |
654 | } | 633 | } |
655 | 634 | ||
635 | static long | ||
636 | hpet_ioctl(struct file *file, unsigned int cmd, unsigned long arg) | ||
637 | { | ||
638 | struct hpet_info info; | ||
639 | int err; | ||
640 | |||
641 | mutex_lock(&hpet_mutex); | ||
642 | err = hpet_ioctl_common(file->private_data, cmd, arg, &info); | ||
643 | mutex_unlock(&hpet_mutex); | ||
644 | |||
645 | if ((cmd == HPET_INFO) && !err && | ||
646 | (copy_to_user((void __user *)arg, &info, sizeof(info)))) | ||
647 | err = -EFAULT; | ||
648 | |||
649 | return err; | ||
650 | } | ||
651 | |||
652 | #ifdef CONFIG_COMPAT | ||
653 | struct compat_hpet_info { | ||
654 | compat_ulong_t hi_ireqfreq; /* Hz */ | ||
655 | compat_ulong_t hi_flags; /* information */ | ||
656 | unsigned short hi_hpet; | ||
657 | unsigned short hi_timer; | ||
658 | }; | ||
659 | |||
660 | static long | ||
661 | hpet_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) | ||
662 | { | ||
663 | struct hpet_info info; | ||
664 | int err; | ||
665 | |||
666 | mutex_lock(&hpet_mutex); | ||
667 | err = hpet_ioctl_common(file->private_data, cmd, arg, &info); | ||
668 | mutex_unlock(&hpet_mutex); | ||
669 | |||
670 | if ((cmd == HPET_INFO) && !err) { | ||
671 | struct compat_hpet_info __user *u = compat_ptr(arg); | ||
672 | if (put_user(info.hi_ireqfreq, &u->hi_ireqfreq) || | ||
673 | put_user(info.hi_flags, &u->hi_flags) || | ||
674 | put_user(info.hi_hpet, &u->hi_hpet) || | ||
675 | put_user(info.hi_timer, &u->hi_timer)) | ||
676 | err = -EFAULT; | ||
677 | } | ||
678 | |||
679 | return err; | ||
680 | } | ||
681 | #endif | ||
682 | |||
656 | static const struct file_operations hpet_fops = { | 683 | static const struct file_operations hpet_fops = { |
657 | .owner = THIS_MODULE, | 684 | .owner = THIS_MODULE, |
658 | .llseek = no_llseek, | 685 | .llseek = no_llseek, |
659 | .read = hpet_read, | 686 | .read = hpet_read, |
660 | .poll = hpet_poll, | 687 | .poll = hpet_poll, |
661 | .unlocked_ioctl = hpet_ioctl, | 688 | .unlocked_ioctl = hpet_ioctl, |
689 | #ifdef CONFIG_COMPAT | ||
690 | .compat_ioctl = hpet_compat_ioctl, | ||
691 | #endif | ||
662 | .open = hpet_open, | 692 | .open = hpet_open, |
663 | .release = hpet_release, | 693 | .release = hpet_release, |
664 | .fasync = hpet_fasync, | 694 | .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 @@ | |||
19 | #include <linux/cdev.h> | 19 | #include <linux/cdev.h> |
20 | #include <linux/device.h> | 20 | #include <linux/device.h> |
21 | #include <linux/mutex.h> | 21 | #include <linux/mutex.h> |
22 | #include <linux/smp_lock.h> | ||
23 | #include <linux/gfp.h> | 22 | #include <linux/gfp.h> |
23 | #include <linux/compat.h> | ||
24 | 24 | ||
25 | #include <asm/uaccess.h> | 25 | #include <asm/uaccess.h> |
26 | 26 | ||
@@ -55,7 +55,6 @@ static int raw_open(struct inode *inode, struct file *filp) | |||
55 | return 0; | 55 | return 0; |
56 | } | 56 | } |
57 | 57 | ||
58 | lock_kernel(); | ||
59 | mutex_lock(&raw_mutex); | 58 | mutex_lock(&raw_mutex); |
60 | 59 | ||
61 | /* | 60 | /* |
@@ -82,7 +81,6 @@ static int raw_open(struct inode *inode, struct file *filp) | |||
82 | bdev->bd_inode->i_mapping; | 81 | bdev->bd_inode->i_mapping; |
83 | filp->private_data = bdev; | 82 | filp->private_data = bdev; |
84 | mutex_unlock(&raw_mutex); | 83 | mutex_unlock(&raw_mutex); |
85 | unlock_kernel(); | ||
86 | return 0; | 84 | return 0; |
87 | 85 | ||
88 | out2: | 86 | out2: |
@@ -91,7 +89,6 @@ out1: | |||
91 | blkdev_put(bdev, filp->f_mode); | 89 | blkdev_put(bdev, filp->f_mode); |
92 | out: | 90 | out: |
93 | mutex_unlock(&raw_mutex); | 91 | mutex_unlock(&raw_mutex); |
94 | unlock_kernel(); | ||
95 | return err; | 92 | return err; |
96 | } | 93 | } |
97 | 94 | ||
@@ -125,20 +122,84 @@ static long | |||
125 | raw_ioctl(struct file *filp, unsigned int command, unsigned long arg) | 122 | raw_ioctl(struct file *filp, unsigned int command, unsigned long arg) |
126 | { | 123 | { |
127 | struct block_device *bdev = filp->private_data; | 124 | struct block_device *bdev = filp->private_data; |
128 | int ret; | 125 | return blkdev_ioctl(bdev, 0, command, arg); |
126 | } | ||
127 | |||
128 | static int bind_set(int number, u64 major, u64 minor) | ||
129 | { | ||
130 | dev_t dev = MKDEV(major, minor); | ||
131 | struct raw_device_data *rawdev; | ||
132 | int err = 0; | ||
129 | 133 | ||
130 | lock_kernel(); | 134 | if (number <= 0 || number >= MAX_RAW_MINORS) |
131 | ret = blkdev_ioctl(bdev, 0, command, arg); | 135 | return -EINVAL; |
132 | unlock_kernel(); | ||
133 | 136 | ||
134 | return ret; | 137 | if (MAJOR(dev) != major || MINOR(dev) != minor) |
138 | return -EINVAL; | ||
139 | |||
140 | rawdev = &raw_devices[number]; | ||
141 | |||
142 | /* | ||
143 | * This is like making block devices, so demand the | ||
144 | * same capability | ||
145 | */ | ||
146 | if (!capable(CAP_SYS_ADMIN)) | ||
147 | return -EPERM; | ||
148 | |||
149 | /* | ||
150 | * For now, we don't need to check that the underlying | ||
151 | * block device is present or not: we can do that when | ||
152 | * the raw device is opened. Just check that the | ||
153 | * major/minor numbers make sense. | ||
154 | */ | ||
155 | |||
156 | if (MAJOR(dev) == 0 && dev != 0) | ||
157 | return -EINVAL; | ||
158 | |||
159 | mutex_lock(&raw_mutex); | ||
160 | if (rawdev->inuse) { | ||
161 | mutex_unlock(&raw_mutex); | ||
162 | return -EBUSY; | ||
163 | } | ||
164 | if (rawdev->binding) { | ||
165 | bdput(rawdev->binding); | ||
166 | module_put(THIS_MODULE); | ||
167 | } | ||
168 | if (!dev) { | ||
169 | /* unbind */ | ||
170 | rawdev->binding = NULL; | ||
171 | device_destroy(raw_class, MKDEV(RAW_MAJOR, number)); | ||
172 | } else { | ||
173 | rawdev->binding = bdget(dev); | ||
174 | if (rawdev->binding == NULL) { | ||
175 | err = -ENOMEM; | ||
176 | } else { | ||
177 | dev_t raw = MKDEV(RAW_MAJOR, number); | ||
178 | __module_get(THIS_MODULE); | ||
179 | device_destroy(raw_class, raw); | ||
180 | device_create(raw_class, NULL, raw, NULL, | ||
181 | "raw%d", number); | ||
182 | } | ||
183 | } | ||
184 | mutex_unlock(&raw_mutex); | ||
185 | return err; | ||
135 | } | 186 | } |
136 | 187 | ||
137 | static void bind_device(struct raw_config_request *rq) | 188 | static int bind_get(int number, dev_t *dev) |
138 | { | 189 | { |
139 | device_destroy(raw_class, MKDEV(RAW_MAJOR, rq->raw_minor)); | 190 | struct raw_device_data *rawdev; |
140 | device_create(raw_class, NULL, MKDEV(RAW_MAJOR, rq->raw_minor), NULL, | 191 | struct block_device *bdev; |
141 | "raw%d", rq->raw_minor); | 192 | |
193 | if (number <= 0 || number >= MAX_RAW_MINORS) | ||
194 | return -EINVAL; | ||
195 | |||
196 | rawdev = &raw_devices[number]; | ||
197 | |||
198 | mutex_lock(&raw_mutex); | ||
199 | bdev = rawdev->binding; | ||
200 | *dev = bdev ? bdev->bd_dev : 0; | ||
201 | mutex_unlock(&raw_mutex); | ||
202 | return 0; | ||
142 | } | 203 | } |
143 | 204 | ||
144 | /* | 205 | /* |
@@ -149,105 +210,78 @@ static long raw_ctl_ioctl(struct file *filp, unsigned int command, | |||
149 | unsigned long arg) | 210 | unsigned long arg) |
150 | { | 211 | { |
151 | struct raw_config_request rq; | 212 | struct raw_config_request rq; |
152 | struct raw_device_data *rawdev; | 213 | dev_t dev; |
153 | int err = 0; | 214 | int err; |
154 | 215 | ||
155 | lock_kernel(); | ||
156 | switch (command) { | 216 | switch (command) { |
157 | case RAW_SETBIND: | 217 | case RAW_SETBIND: |
218 | if (copy_from_user(&rq, (void __user *) arg, sizeof(rq))) | ||
219 | return -EFAULT; | ||
220 | |||
221 | return bind_set(rq.raw_minor, rq.block_major, rq.block_minor); | ||
222 | |||
158 | case RAW_GETBIND: | 223 | case RAW_GETBIND: |
224 | if (copy_from_user(&rq, (void __user *) arg, sizeof(rq))) | ||
225 | return -EFAULT; | ||
159 | 226 | ||
160 | /* First, find out which raw minor we want */ | 227 | err = bind_get(rq.raw_minor, &dev); |
228 | if (err) | ||
229 | return err; | ||
161 | 230 | ||
162 | if (copy_from_user(&rq, (void __user *) arg, sizeof(rq))) { | 231 | rq.block_major = MAJOR(dev); |
163 | err = -EFAULT; | 232 | rq.block_minor = MINOR(dev); |
164 | goto out; | ||
165 | } | ||
166 | 233 | ||
167 | if (rq.raw_minor <= 0 || rq.raw_minor >= MAX_RAW_MINORS) { | 234 | if (copy_to_user((void __user *)arg, &rq, sizeof(rq))) |
168 | err = -EINVAL; | 235 | return -EFAULT; |
169 | goto out; | 236 | |
170 | } | 237 | return 0; |
171 | rawdev = &raw_devices[rq.raw_minor]; | ||
172 | |||
173 | if (command == RAW_SETBIND) { | ||
174 | dev_t dev; | ||
175 | |||
176 | /* | ||
177 | * This is like making block devices, so demand the | ||
178 | * same capability | ||
179 | */ | ||
180 | if (!capable(CAP_SYS_ADMIN)) { | ||
181 | err = -EPERM; | ||
182 | goto out; | ||
183 | } | ||
184 | |||
185 | /* | ||
186 | * For now, we don't need to check that the underlying | ||
187 | * block device is present or not: we can do that when | ||
188 | * the raw device is opened. Just check that the | ||
189 | * major/minor numbers make sense. | ||
190 | */ | ||
191 | |||
192 | dev = MKDEV(rq.block_major, rq.block_minor); | ||
193 | if ((rq.block_major == 0 && rq.block_minor != 0) || | ||
194 | MAJOR(dev) != rq.block_major || | ||
195 | MINOR(dev) != rq.block_minor) { | ||
196 | err = -EINVAL; | ||
197 | goto out; | ||
198 | } | ||
199 | |||
200 | mutex_lock(&raw_mutex); | ||
201 | if (rawdev->inuse) { | ||
202 | mutex_unlock(&raw_mutex); | ||
203 | err = -EBUSY; | ||
204 | goto out; | ||
205 | } | ||
206 | if (rawdev->binding) { | ||
207 | bdput(rawdev->binding); | ||
208 | module_put(THIS_MODULE); | ||
209 | } | ||
210 | if (rq.block_major == 0 && rq.block_minor == 0) { | ||
211 | /* unbind */ | ||
212 | rawdev->binding = NULL; | ||
213 | device_destroy(raw_class, | ||
214 | MKDEV(RAW_MAJOR, rq.raw_minor)); | ||
215 | } else { | ||
216 | rawdev->binding = bdget(dev); | ||
217 | if (rawdev->binding == NULL) | ||
218 | err = -ENOMEM; | ||
219 | else { | ||
220 | __module_get(THIS_MODULE); | ||
221 | bind_device(&rq); | ||
222 | } | ||
223 | } | ||
224 | mutex_unlock(&raw_mutex); | ||
225 | } else { | ||
226 | struct block_device *bdev; | ||
227 | |||
228 | mutex_lock(&raw_mutex); | ||
229 | bdev = rawdev->binding; | ||
230 | if (bdev) { | ||
231 | rq.block_major = MAJOR(bdev->bd_dev); | ||
232 | rq.block_minor = MINOR(bdev->bd_dev); | ||
233 | } else { | ||
234 | rq.block_major = rq.block_minor = 0; | ||
235 | } | ||
236 | mutex_unlock(&raw_mutex); | ||
237 | if (copy_to_user((void __user *)arg, &rq, sizeof(rq))) { | ||
238 | err = -EFAULT; | ||
239 | goto out; | ||
240 | } | ||
241 | } | ||
242 | break; | ||
243 | default: | ||
244 | err = -EINVAL; | ||
245 | break; | ||
246 | } | 238 | } |
247 | out: | 239 | |
248 | unlock_kernel(); | 240 | return -EINVAL; |
249 | return err; | 241 | } |
242 | |||
243 | #ifdef CONFIG_COMPAT | ||
244 | struct raw32_config_request { | ||
245 | compat_int_t raw_minor; | ||
246 | compat_u64 block_major; | ||
247 | compat_u64 block_minor; | ||
248 | }; | ||
249 | |||
250 | static long raw_ctl_compat_ioctl(struct file *file, unsigned int cmd, | ||
251 | unsigned long arg) | ||
252 | { | ||
253 | struct raw32_config_request __user *user_req = compat_ptr(arg); | ||
254 | struct raw32_config_request rq; | ||
255 | dev_t dev; | ||
256 | int err = 0; | ||
257 | |||
258 | switch (cmd) { | ||
259 | case RAW_SETBIND: | ||
260 | if (copy_from_user(&rq, user_req, sizeof(rq))) | ||
261 | return -EFAULT; | ||
262 | |||
263 | return bind_set(rq.raw_minor, rq.block_major, rq.block_minor); | ||
264 | |||
265 | case RAW_GETBIND: | ||
266 | if (copy_from_user(&rq, user_req, sizeof(rq))) | ||
267 | return -EFAULT; | ||
268 | |||
269 | err = bind_get(rq.raw_minor, &dev); | ||
270 | if (err) | ||
271 | return err; | ||
272 | |||
273 | rq.block_major = MAJOR(dev); | ||
274 | rq.block_minor = MINOR(dev); | ||
275 | |||
276 | if (copy_to_user(user_req, &rq, sizeof(rq))) | ||
277 | return -EFAULT; | ||
278 | |||
279 | return 0; | ||
280 | } | ||
281 | |||
282 | return -EINVAL; | ||
250 | } | 283 | } |
284 | #endif | ||
251 | 285 | ||
252 | static const struct file_operations raw_fops = { | 286 | static const struct file_operations raw_fops = { |
253 | .read = do_sync_read, | 287 | .read = do_sync_read, |
@@ -263,6 +297,9 @@ static const struct file_operations raw_fops = { | |||
263 | 297 | ||
264 | static const struct file_operations raw_ctl_fops = { | 298 | static const struct file_operations raw_ctl_fops = { |
265 | .unlocked_ioctl = raw_ctl_ioctl, | 299 | .unlocked_ioctl = raw_ctl_ioctl, |
300 | #ifdef CONFIG_COMPAT | ||
301 | .compat_ioctl = raw_ctl_compat_ioctl, | ||
302 | #endif | ||
266 | .open = raw_open, | 303 | .open = raw_open, |
267 | .owner = THIS_MODULE, | 304 | .owner = THIS_MODULE, |
268 | }; | 305 | }; |
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 @@ | |||
37 | #include <linux/ioport.h> | 37 | #include <linux/ioport.h> |
38 | #include <linux/interrupt.h> | 38 | #include <linux/interrupt.h> |
39 | #include <linux/spinlock.h> | 39 | #include <linux/spinlock.h> |
40 | #include <linux/smp_lock.h> | 40 | #include <linux/mutex.h> |
41 | #include <linux/timer.h> | 41 | #include <linux/timer.h> |
42 | #include <linux/sysfs.h> | 42 | #include <linux/sysfs.h> |
43 | #include <linux/device.h> | 43 | #include <linux/device.h> |
@@ -206,7 +206,7 @@ static int tlclk_open(struct inode *inode, struct file *filp) | |||
206 | { | 206 | { |
207 | int result; | 207 | int result; |
208 | 208 | ||
209 | lock_kernel(); | 209 | mutex_lock(&tlclk_mutex); |
210 | if (test_and_set_bit(0, &useflags)) { | 210 | if (test_and_set_bit(0, &useflags)) { |
211 | result = -EBUSY; | 211 | result = -EBUSY; |
212 | /* this legacy device is always one per system and it doesn't | 212 | /* 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) | |||
229 | inb(TLCLK_REG6); /* Clear interrupt events */ | 229 | inb(TLCLK_REG6); /* Clear interrupt events */ |
230 | 230 | ||
231 | out: | 231 | out: |
232 | unlock_kernel(); | 232 | mutex_unlock(&tlclk_mutex); |
233 | return result; | 233 | return result; |
234 | } | 234 | } |
235 | 235 | ||
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" | |||
73 | 73 | ||
74 | config DRM_I810 | 74 | config DRM_I810 |
75 | tristate "Intel I810" | 75 | tristate "Intel I810" |
76 | depends on DRM && AGP && AGP_INTEL | 76 | # BKL usage in order to avoid AB-BA deadlocks, may become BROKEN_ON_SMP |
77 | depends on DRM && AGP && AGP_INTEL && BKL | ||
77 | help | 78 | help |
78 | Choose this option if you have an Intel I810 graphics card. If M is | 79 | Choose this option if you have an Intel I810 graphics card. If M is |
79 | selected, the module will be called i810. AGP support is required | 80 | selected, the module will be called i810. AGP support is required |
@@ -86,6 +87,8 @@ choice | |||
86 | 87 | ||
87 | config DRM_I830 | 88 | config DRM_I830 |
88 | tristate "i830 driver" | 89 | tristate "i830 driver" |
90 | # BKL usage in order to avoid AB-BA deadlocks, i830 may get removed | ||
91 | depends on BKL | ||
89 | help | 92 | help |
90 | Choose this option if you have a system that has Intel 830M, 845G, | 93 | Choose this option if you have a system that has Intel 830M, 845G, |
91 | 852GM, 855GM or 865G integrated graphics. If M is selected, the | 94 | 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" | |||
19 | 19 | ||
20 | config VIDEO_DEV | 20 | config VIDEO_DEV |
21 | tristate "Video For Linux" | 21 | tristate "Video For Linux" |
22 | depends on BKL # used in many drivers for ioctl handling, need to kill | ||
22 | ---help--- | 23 | ---help--- |
23 | V4L core support for video capture and overlay devices, webcams and | 24 | V4L core support for video capture and overlay devices, webcams and |
24 | AM/FM radio cards. | 25 | 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 @@ | |||
22 | #include <linux/module.h> | 22 | #include <linux/module.h> |
23 | #include <linux/slab.h> | 23 | #include <linux/slab.h> |
24 | #include <linux/init.h> | 24 | #include <linux/init.h> |
25 | #include <linux/smp_lock.h> | 25 | #include <linux/mutex.h> |
26 | #include <linux/string.h> | 26 | #include <linux/string.h> |
27 | #include <linux/dvb/ca.h> | 27 | #include <linux/dvb/ca.h> |
28 | #include "dvbdev.h" | 28 | #include "dvbdev.h" |
@@ -52,6 +52,7 @@ | |||
52 | } while(0) | 52 | } while(0) |
53 | 53 | ||
54 | 54 | ||
55 | static DEFINE_MUTEX(dst_ca_mutex); | ||
55 | static unsigned int verbose = 5; | 56 | static unsigned int verbose = 5; |
56 | module_param(verbose, int, 0644); | 57 | module_param(verbose, int, 0644); |
57 | MODULE_PARM_DESC(verbose, "verbose startup messages, default is 1 (yes)"); | 58 | 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 | |||
564 | void __user *arg = (void __user *)ioctl_arg; | 565 | void __user *arg = (void __user *)ioctl_arg; |
565 | int result = 0; | 566 | int result = 0; |
566 | 567 | ||
567 | lock_kernel(); | 568 | mutex_lock(&dst_ca_mutex); |
568 | dvbdev = file->private_data; | 569 | dvbdev = file->private_data; |
569 | state = (struct dst_state *)dvbdev->priv; | 570 | state = (struct dst_state *)dvbdev->priv; |
570 | p_ca_message = kmalloc(sizeof (struct ca_msg), GFP_KERNEL); | 571 | 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 | |||
652 | kfree (p_ca_slot_info); | 653 | kfree (p_ca_slot_info); |
653 | kfree (p_ca_caps); | 654 | kfree (p_ca_caps); |
654 | 655 | ||
655 | unlock_kernel(); | 656 | mutex_unlock(&dst_ca_mutex); |
656 | return result; | 657 | return result; |
657 | } | 658 | } |
658 | 659 | ||
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 @@ | |||
25 | #include <linux/slab.h> | 25 | #include <linux/slab.h> |
26 | #include <linux/vmalloc.h> | 26 | #include <linux/vmalloc.h> |
27 | #include <linux/module.h> | 27 | #include <linux/module.h> |
28 | #include <linux/smp_lock.h> | ||
29 | #include <linux/poll.h> | 28 | #include <linux/poll.h> |
30 | #include <linux/ioctl.h> | 29 | #include <linux/ioctl.h> |
31 | #include <linux/wait.h> | 30 | #include <linux/wait.h> |
@@ -1088,13 +1087,7 @@ static int dvb_demux_do_ioctl(struct file *file, | |||
1088 | static long dvb_demux_ioctl(struct file *file, unsigned int cmd, | 1087 | static long dvb_demux_ioctl(struct file *file, unsigned int cmd, |
1089 | unsigned long arg) | 1088 | unsigned long arg) |
1090 | { | 1089 | { |
1091 | int ret; | 1090 | return dvb_usercopy(file, cmd, arg, dvb_demux_do_ioctl); |
1092 | |||
1093 | lock_kernel(); | ||
1094 | ret = dvb_usercopy(file, cmd, arg, dvb_demux_do_ioctl); | ||
1095 | unlock_kernel(); | ||
1096 | |||
1097 | return ret; | ||
1098 | } | 1091 | } |
1099 | 1092 | ||
1100 | static unsigned int dvb_demux_poll(struct file *file, poll_table *wait) | 1093 | 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, | |||
1186 | static long dvb_dvr_ioctl(struct file *file, | 1179 | static long dvb_dvr_ioctl(struct file *file, |
1187 | unsigned int cmd, unsigned long arg) | 1180 | unsigned int cmd, unsigned long arg) |
1188 | { | 1181 | { |
1189 | int ret; | 1182 | return dvb_usercopy(file, cmd, arg, dvb_dvr_do_ioctl); |
1190 | |||
1191 | lock_kernel(); | ||
1192 | ret = dvb_usercopy(file, cmd, arg, dvb_dvr_do_ioctl); | ||
1193 | unlock_kernel(); | ||
1194 | |||
1195 | return ret; | ||
1196 | } | 1183 | } |
1197 | 1184 | ||
1198 | static unsigned int dvb_dvr_poll(struct file *file, poll_table *wait) | 1185 | 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, | |||
1259 | static long dvb_ca_en50221_io_ioctl(struct file *file, | 1259 | static long dvb_ca_en50221_io_ioctl(struct file *file, |
1260 | unsigned int cmd, unsigned long arg) | 1260 | unsigned int cmd, unsigned long arg) |
1261 | { | 1261 | { |
1262 | int ret; | 1262 | return dvb_usercopy(file, cmd, arg, dvb_ca_en50221_io_do_ioctl); |
1263 | |||
1264 | lock_kernel(); | ||
1265 | ret = dvb_usercopy(file, cmd, arg, dvb_ca_en50221_io_do_ioctl); | ||
1266 | unlock_kernel(); | ||
1267 | |||
1268 | return ret; | ||
1269 | } | 1263 | } |
1270 | 1264 | ||
1271 | 1265 | ||
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 @@ | |||
59 | #include <linux/netdevice.h> | 59 | #include <linux/netdevice.h> |
60 | #include <linux/etherdevice.h> | 60 | #include <linux/etherdevice.h> |
61 | #include <linux/dvb/net.h> | 61 | #include <linux/dvb/net.h> |
62 | #include <linux/smp_lock.h> | ||
63 | #include <linux/uio.h> | 62 | #include <linux/uio.h> |
64 | #include <asm/uaccess.h> | 63 | #include <asm/uaccess.h> |
65 | #include <linux/crc32.h> | 64 | #include <linux/crc32.h> |
@@ -1445,13 +1444,7 @@ static int dvb_net_do_ioctl(struct file *file, | |||
1445 | static long dvb_net_ioctl(struct file *file, | 1444 | static long dvb_net_ioctl(struct file *file, |
1446 | unsigned int cmd, unsigned long arg) | 1445 | unsigned int cmd, unsigned long arg) |
1447 | { | 1446 | { |
1448 | int ret; | 1447 | return dvb_usercopy(file, cmd, arg, dvb_net_do_ioctl); |
1449 | |||
1450 | lock_kernel(); | ||
1451 | ret = dvb_usercopy(file, cmd, arg, dvb_net_do_ioctl); | ||
1452 | unlock_kernel(); | ||
1453 | |||
1454 | return ret; | ||
1455 | } | 1448 | } |
1456 | 1449 | ||
1457 | static int dvb_net_close(struct inode *inode, struct file *file) | 1450 | 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 @@ | |||
32 | #include <linux/fs.h> | 32 | #include <linux/fs.h> |
33 | #include <linux/cdev.h> | 33 | #include <linux/cdev.h> |
34 | #include <linux/mutex.h> | 34 | #include <linux/mutex.h> |
35 | #include <linux/smp_lock.h> | ||
36 | #include "dvbdev.h" | 35 | #include "dvbdev.h" |
37 | 36 | ||
37 | static DEFINE_MUTEX(dvbdev_mutex); | ||
38 | static int dvbdev_debug; | 38 | static int dvbdev_debug; |
39 | 39 | ||
40 | module_param(dvbdev_debug, int, 0644); | 40 | module_param(dvbdev_debug, int, 0644); |
@@ -68,7 +68,7 @@ static int dvb_device_open(struct inode *inode, struct file *file) | |||
68 | { | 68 | { |
69 | struct dvb_device *dvbdev; | 69 | struct dvb_device *dvbdev; |
70 | 70 | ||
71 | lock_kernel(); | 71 | mutex_lock(&dvbdev_mutex); |
72 | down_read(&minor_rwsem); | 72 | down_read(&minor_rwsem); |
73 | dvbdev = dvb_minors[iminor(inode)]; | 73 | dvbdev = dvb_minors[iminor(inode)]; |
74 | 74 | ||
@@ -91,12 +91,12 @@ static int dvb_device_open(struct inode *inode, struct file *file) | |||
91 | } | 91 | } |
92 | fops_put(old_fops); | 92 | fops_put(old_fops); |
93 | up_read(&minor_rwsem); | 93 | up_read(&minor_rwsem); |
94 | unlock_kernel(); | 94 | mutex_unlock(&dvbdev_mutex); |
95 | return err; | 95 | return err; |
96 | } | 96 | } |
97 | fail: | 97 | fail: |
98 | up_read(&minor_rwsem); | 98 | up_read(&minor_rwsem); |
99 | unlock_kernel(); | 99 | mutex_unlock(&dvbdev_mutex); |
100 | return -ENODEV; | 100 | return -ENODEV; |
101 | } | 101 | } |
102 | 102 | ||
@@ -158,7 +158,6 @@ long dvb_generic_ioctl(struct file *file, | |||
158 | unsigned int cmd, unsigned long arg) | 158 | unsigned int cmd, unsigned long arg) |
159 | { | 159 | { |
160 | struct dvb_device *dvbdev = file->private_data; | 160 | struct dvb_device *dvbdev = file->private_data; |
161 | int ret; | ||
162 | 161 | ||
163 | if (!dvbdev) | 162 | if (!dvbdev) |
164 | return -ENODEV; | 163 | return -ENODEV; |
@@ -166,11 +165,7 @@ long dvb_generic_ioctl(struct file *file, | |||
166 | if (!dvbdev->kernel_ioctl) | 165 | if (!dvbdev->kernel_ioctl) |
167 | return -EINVAL; | 166 | return -EINVAL; |
168 | 167 | ||
169 | lock_kernel(); | 168 | return dvb_usercopy(file, cmd, arg, dvbdev->kernel_ioctl); |
170 | ret = dvb_usercopy(file, cmd, arg, dvbdev->kernel_ioctl); | ||
171 | unlock_kernel(); | ||
172 | |||
173 | return ret; | ||
174 | } | 169 | } |
175 | EXPORT_SYMBOL(dvb_generic_ioctl); | 170 | EXPORT_SYMBOL(dvb_generic_ioctl); |
176 | 171 | ||
@@ -421,8 +416,10 @@ int dvb_usercopy(struct file *file, | |||
421 | } | 416 | } |
422 | 417 | ||
423 | /* call driver */ | 418 | /* call driver */ |
419 | mutex_lock(&dvbdev_mutex); | ||
424 | if ((err = func(file, cmd, parg)) == -ENOIOCTLCMD) | 420 | if ((err = func(file, cmd, parg)) == -ENOIOCTLCMD) |
425 | err = -EINVAL; | 421 | err = -EINVAL; |
422 | mutex_unlock(&dvbdev_mutex); | ||
426 | 423 | ||
427 | if (err < 0) | 424 | if (err < 0) |
428 | goto out; | 425 | 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 @@ | |||
32 | #include <linux/list.h> | 32 | #include <linux/list.h> |
33 | #include <linux/vmalloc.h> | 33 | #include <linux/vmalloc.h> |
34 | #include <linux/slab.h> | 34 | #include <linux/slab.h> |
35 | #include <linux/smp_lock.h> | ||
36 | #include <linux/init.h> | 35 | #include <linux/init.h> |
37 | #include <asm/uaccess.h> | 36 | #include <asm/uaccess.h> |
38 | #include <asm/atomic.h> | 37 | #include <asm/atomic.h> |
@@ -621,7 +620,6 @@ static int dabusb_open (struct inode *inode, struct file *file) | |||
621 | if (devnum < DABUSB_MINOR || devnum >= (DABUSB_MINOR + NRDABUSB)) | 620 | if (devnum < DABUSB_MINOR || devnum >= (DABUSB_MINOR + NRDABUSB)) |
622 | return -EIO; | 621 | return -EIO; |
623 | 622 | ||
624 | lock_kernel(); | ||
625 | s = &dabusb[devnum - DABUSB_MINOR]; | 623 | s = &dabusb[devnum - DABUSB_MINOR]; |
626 | 624 | ||
627 | dbg("dabusb_open"); | 625 | dbg("dabusb_open"); |
@@ -630,21 +628,17 @@ static int dabusb_open (struct inode *inode, struct file *file) | |||
630 | while (!s->usbdev || s->opened) { | 628 | while (!s->usbdev || s->opened) { |
631 | mutex_unlock(&s->mutex); | 629 | mutex_unlock(&s->mutex); |
632 | 630 | ||
633 | if (file->f_flags & O_NONBLOCK) { | 631 | if (file->f_flags & O_NONBLOCK) |
634 | return -EBUSY; | 632 | return -EBUSY; |
635 | } | ||
636 | msleep_interruptible(500); | 633 | msleep_interruptible(500); |
637 | 634 | ||
638 | if (signal_pending (current)) { | 635 | if (signal_pending (current)) |
639 | unlock_kernel(); | ||
640 | return -EAGAIN; | 636 | return -EAGAIN; |
641 | } | ||
642 | mutex_lock(&s->mutex); | 637 | mutex_lock(&s->mutex); |
643 | } | 638 | } |
644 | if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) { | 639 | if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) { |
645 | mutex_unlock(&s->mutex); | 640 | mutex_unlock(&s->mutex); |
646 | dev_err(&s->usbdev->dev, "set_interface failed\n"); | 641 | dev_err(&s->usbdev->dev, "set_interface failed\n"); |
647 | unlock_kernel(); | ||
648 | return -EINVAL; | 642 | return -EINVAL; |
649 | } | 643 | } |
650 | s->opened = 1; | 644 | s->opened = 1; |
@@ -654,7 +648,6 @@ static int dabusb_open (struct inode *inode, struct file *file) | |||
654 | file->private_data = s; | 648 | file->private_data = s; |
655 | 649 | ||
656 | r = nonseekable_open(inode, file); | 650 | r = nonseekable_open(inode, file); |
657 | unlock_kernel(); | ||
658 | return r; | 651 | return r; |
659 | } | 652 | } |
660 | 653 | ||
@@ -689,17 +682,13 @@ static long dabusb_ioctl (struct file *file, unsigned int cmd, unsigned long arg | |||
689 | 682 | ||
690 | dbg("dabusb_ioctl"); | 683 | dbg("dabusb_ioctl"); |
691 | 684 | ||
692 | lock_kernel(); | 685 | if (s->remove_pending) |
693 | if (s->remove_pending) { | ||
694 | unlock_kernel(); | ||
695 | return -EIO; | 686 | return -EIO; |
696 | } | ||
697 | 687 | ||
698 | mutex_lock(&s->mutex); | 688 | mutex_lock(&s->mutex); |
699 | 689 | ||
700 | if (!s->usbdev) { | 690 | if (!s->usbdev) { |
701 | mutex_unlock(&s->mutex); | 691 | mutex_unlock(&s->mutex); |
702 | unlock_kernel(); | ||
703 | return -EIO; | 692 | return -EIO; |
704 | } | 693 | } |
705 | 694 | ||
@@ -735,7 +724,6 @@ static long dabusb_ioctl (struct file *file, unsigned int cmd, unsigned long arg | |||
735 | break; | 724 | break; |
736 | } | 725 | } |
737 | mutex_unlock(&s->mutex); | 726 | mutex_unlock(&s->mutex); |
738 | unlock_kernel(); | ||
739 | return ret; | 727 | return ret; |
740 | } | 728 | } |
741 | 729 | ||
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 @@ | |||
3 | # | 3 | # |
4 | config ATALK | 4 | config ATALK |
5 | tristate "Appletalk protocol support" | 5 | tristate "Appletalk protocol support" |
6 | depends on BKL # waiting to be removed from net/appletalk/ddp.c | ||
6 | select LLC | 7 | select LLC |
7 | ---help--- | 8 | ---help--- |
8 | AppleTalk is the protocol that Apple computers can use to communicate | 9 | 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; | |||
31 | static loff_t isapnp_proc_bus_lseek(struct file *file, loff_t off, int whence) | 31 | static loff_t isapnp_proc_bus_lseek(struct file *file, loff_t off, int whence) |
32 | { | 32 | { |
33 | loff_t new = -1; | 33 | loff_t new = -1; |
34 | struct inode *inode = file->f_path.dentry->d_inode; | ||
34 | 35 | ||
35 | lock_kernel(); | 36 | mutex_lock(&inode->i_mutex); |
36 | switch (whence) { | 37 | switch (whence) { |
37 | case 0: | 38 | case 0: |
38 | new = off; | 39 | new = off; |
@@ -44,12 +45,12 @@ static loff_t isapnp_proc_bus_lseek(struct file *file, loff_t off, int whence) | |||
44 | new = 256 + off; | 45 | new = 256 + off; |
45 | break; | 46 | break; |
46 | } | 47 | } |
47 | if (new < 0 || new > 256) { | 48 | if (new < 0 || new > 256) |
48 | unlock_kernel(); | 49 | new = -EINVAL; |
49 | return -EINVAL; | 50 | else |
50 | } | 51 | file->f_pos = new; |
51 | unlock_kernel(); | 52 | mutex_unlock(&inode->i_mutex); |
52 | return (file->f_pos = new); | 53 | return new; |
53 | } | 54 | } |
54 | 55 | ||
55 | static ssize_t isapnp_proc_bus_read(struct file *file, char __user * buf, | 56 | 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 @@ | |||
21 | #include <linux/hdreg.h> | 21 | #include <linux/hdreg.h> |
22 | #include <linux/async.h> | 22 | #include <linux/async.h> |
23 | #include <linux/mutex.h> | 23 | #include <linux/mutex.h> |
24 | #include <linux/smp_lock.h> | ||
25 | 24 | ||
26 | #include <asm/ccwdev.h> | 25 | #include <asm/ccwdev.h> |
27 | #include <asm/ebcdic.h> | 26 | #include <asm/ebcdic.h> |
@@ -2236,7 +2235,6 @@ static int dasd_open(struct block_device *bdev, fmode_t mode) | |||
2236 | if (!block) | 2235 | if (!block) |
2237 | return -ENODEV; | 2236 | return -ENODEV; |
2238 | 2237 | ||
2239 | lock_kernel(); | ||
2240 | base = block->base; | 2238 | base = block->base; |
2241 | atomic_inc(&block->open_count); | 2239 | atomic_inc(&block->open_count); |
2242 | if (test_bit(DASD_FLAG_OFFLINE, &base->flags)) { | 2240 | if (test_bit(DASD_FLAG_OFFLINE, &base->flags)) { |
@@ -2271,14 +2269,12 @@ static int dasd_open(struct block_device *bdev, fmode_t mode) | |||
2271 | goto out; | 2269 | goto out; |
2272 | } | 2270 | } |
2273 | 2271 | ||
2274 | unlock_kernel(); | ||
2275 | return 0; | 2272 | return 0; |
2276 | 2273 | ||
2277 | out: | 2274 | out: |
2278 | module_put(base->discipline->owner); | 2275 | module_put(base->discipline->owner); |
2279 | unlock: | 2276 | unlock: |
2280 | atomic_dec(&block->open_count); | 2277 | atomic_dec(&block->open_count); |
2281 | unlock_kernel(); | ||
2282 | return rc; | 2278 | return rc; |
2283 | } | 2279 | } |
2284 | 2280 | ||
@@ -2286,10 +2282,8 @@ static int dasd_release(struct gendisk *disk, fmode_t mode) | |||
2286 | { | 2282 | { |
2287 | struct dasd_block *block = disk->private_data; | 2283 | struct dasd_block *block = disk->private_data; |
2288 | 2284 | ||
2289 | lock_kernel(); | ||
2290 | atomic_dec(&block->open_count); | 2285 | atomic_dec(&block->open_count); |
2291 | module_put(block->base->discipline->owner); | 2286 | module_put(block->base->discipline->owner); |
2292 | unlock_kernel(); | ||
2293 | return 0; | 2287 | return 0; |
2294 | } | 2288 | } |
2295 | 2289 | ||
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 @@ | |||
16 | #include <linux/major.h> | 16 | #include <linux/major.h> |
17 | #include <linux/fs.h> | 17 | #include <linux/fs.h> |
18 | #include <linux/blkpg.h> | 18 | #include <linux/blkpg.h> |
19 | #include <linux/smp_lock.h> | ||
20 | #include <linux/slab.h> | 19 | #include <linux/slab.h> |
21 | #include <asm/compat.h> | 20 | #include <asm/compat.h> |
22 | #include <asm/ccwdev.h> | 21 | #include <asm/ccwdev.h> |
@@ -370,9 +369,8 @@ static int dasd_ioctl_readall_cmb(struct dasd_block *block, unsigned int cmd, | |||
370 | return ret; | 369 | return ret; |
371 | } | 370 | } |
372 | 371 | ||
373 | static int | 372 | int dasd_ioctl(struct block_device *bdev, fmode_t mode, |
374 | dasd_do_ioctl(struct block_device *bdev, fmode_t mode, | 373 | unsigned int cmd, unsigned long arg) |
375 | unsigned int cmd, unsigned long arg) | ||
376 | { | 374 | { |
377 | struct dasd_block *block = bdev->bd_disk->private_data; | 375 | struct dasd_block *block = bdev->bd_disk->private_data; |
378 | void __user *argp; | 376 | void __user *argp; |
@@ -430,14 +428,3 @@ dasd_do_ioctl(struct block_device *bdev, fmode_t mode, | |||
430 | return -EINVAL; | 428 | return -EINVAL; |
431 | } | 429 | } |
432 | } | 430 | } |
433 | |||
434 | int dasd_ioctl(struct block_device *bdev, fmode_t mode, | ||
435 | unsigned int cmd, unsigned long arg) | ||
436 | { | ||
437 | int rc; | ||
438 | |||
439 | lock_kernel(); | ||
440 | rc = dasd_do_ioctl(bdev, mode, cmd, arg); | ||
441 | unlock_kernel(); | ||
442 | return rc; | ||
443 | } | ||
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 @@ | |||
14 | #include <linux/init.h> | 14 | #include <linux/init.h> |
15 | #include <linux/slab.h> | 15 | #include <linux/slab.h> |
16 | #include <linux/blkdev.h> | 16 | #include <linux/blkdev.h> |
17 | #include <linux/smp_lock.h> | ||
18 | #include <linux/completion.h> | 17 | #include <linux/completion.h> |
19 | #include <linux/interrupt.h> | 18 | #include <linux/interrupt.h> |
20 | #include <linux/platform_device.h> | 19 | #include <linux/platform_device.h> |
@@ -776,7 +775,6 @@ dcssblk_open(struct block_device *bdev, fmode_t mode) | |||
776 | struct dcssblk_dev_info *dev_info; | 775 | struct dcssblk_dev_info *dev_info; |
777 | int rc; | 776 | int rc; |
778 | 777 | ||
779 | lock_kernel(); | ||
780 | dev_info = bdev->bd_disk->private_data; | 778 | dev_info = bdev->bd_disk->private_data; |
781 | if (NULL == dev_info) { | 779 | if (NULL == dev_info) { |
782 | rc = -ENODEV; | 780 | rc = -ENODEV; |
@@ -786,7 +784,6 @@ dcssblk_open(struct block_device *bdev, fmode_t mode) | |||
786 | bdev->bd_block_size = 4096; | 784 | bdev->bd_block_size = 4096; |
787 | rc = 0; | 785 | rc = 0; |
788 | out: | 786 | out: |
789 | unlock_kernel(); | ||
790 | return rc; | 787 | return rc; |
791 | } | 788 | } |
792 | 789 | ||
@@ -797,7 +794,6 @@ dcssblk_release(struct gendisk *disk, fmode_t mode) | |||
797 | struct segment_info *entry; | 794 | struct segment_info *entry; |
798 | int rc; | 795 | int rc; |
799 | 796 | ||
800 | lock_kernel(); | ||
801 | if (!dev_info) { | 797 | if (!dev_info) { |
802 | rc = -ENODEV; | 798 | rc = -ENODEV; |
803 | goto out; | 799 | goto out; |
@@ -815,7 +811,6 @@ dcssblk_release(struct gendisk *disk, fmode_t mode) | |||
815 | up_write(&dcssblk_devices_sem); | 811 | up_write(&dcssblk_devices_sem); |
816 | rc = 0; | 812 | rc = 0; |
817 | out: | 813 | out: |
818 | unlock_kernel(); | ||
819 | return rc; | 814 | return rc; |
820 | } | 815 | } |
821 | 816 | ||
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 @@ | |||
1 | config VIDEO_CX25821 | 1 | config VIDEO_CX25821 |
2 | tristate "Conexant cx25821 support" | 2 | tristate "Conexant cx25821 support" |
3 | depends on DVB_CORE && VIDEO_DEV && PCI && I2C && INPUT | 3 | depends on DVB_CORE && VIDEO_DEV && PCI && I2C && INPUT |
4 | depends on BKL # please fix | ||
4 | select I2C_ALGOBIT | 5 | select I2C_ALGOBIT |
5 | select VIDEO_BTCX | 6 | select VIDEO_BTCX |
6 | select VIDEO_TVEEPROM | 7 | 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 @@ | |||
1 | config EASYCAP | 1 | config EASYCAP |
2 | tristate "EasyCAP USB ID 05e1:0408 support" | 2 | tristate "EasyCAP USB ID 05e1:0408 support" |
3 | depends on USB && VIDEO_DEV | 3 | depends on USB && VIDEO_DEV |
4 | depends on BKL # please fix | ||
4 | 5 | ||
5 | ---help--- | 6 | ---help--- |
6 | This is an integrated audio/video driver for EasyCAP cards with | 7 | 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 @@ | |||
1 | config VIDEO_GO7007 | 1 | config VIDEO_GO7007 |
2 | tristate "WIS GO7007 MPEG encoder support" | 2 | tristate "WIS GO7007 MPEG encoder support" |
3 | depends on VIDEO_DEV && PCI && I2C && INPUT | 3 | depends on VIDEO_DEV && PCI && I2C && INPUT |
4 | depends on BKL # please fix | ||
4 | depends on SND | 5 | depends on SND |
5 | select VIDEOBUF_DMA_SG | 6 | select VIDEOBUF_DMA_SG |
6 | select VIDEO_IR | 7 | 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 @@ | |||
1 | config USB_IP_COMMON | 1 | config USB_IP_COMMON |
2 | tristate "USB IP support (EXPERIMENTAL)" | 2 | tristate "USB IP support (EXPERIMENTAL)" |
3 | depends on USB && NET && EXPERIMENTAL | 3 | depends on USB && NET && EXPERIMENTAL && BKL |
4 | default N | 4 | default N |
5 | ---help--- | 5 | ---help--- |
6 | This enables pushing USB packets over IP to allow remote | 6 | This enables pushing USB packets over IP to allow remote |
diff --git a/fs/Kconfig b/fs/Kconfig index 3d185308ec88..65781de44fc0 100644 --- a/fs/Kconfig +++ b/fs/Kconfig | |||
@@ -50,6 +50,7 @@ endif # BLOCK | |||
50 | config FILE_LOCKING | 50 | config FILE_LOCKING |
51 | bool "Enable POSIX file locking API" if EMBEDDED | 51 | bool "Enable POSIX file locking API" if EMBEDDED |
52 | default y | 52 | default y |
53 | select BKL # while lockd still uses it. | ||
53 | help | 54 | help |
54 | This option enables standard file locking support, required | 55 | This option enables standard file locking support, required |
55 | for filesystems like NFS and for the flock() system | 56 | for filesystems like NFS and for the flock() system |
diff --git a/fs/adfs/Kconfig b/fs/adfs/Kconfig index e55182a74605..1dd5f34b3cf2 100644 --- a/fs/adfs/Kconfig +++ b/fs/adfs/Kconfig | |||
@@ -1,6 +1,7 @@ | |||
1 | config ADFS_FS | 1 | config ADFS_FS |
2 | tristate "ADFS file system support (EXPERIMENTAL)" | 2 | tristate "ADFS file system support (EXPERIMENTAL)" |
3 | depends on BLOCK && EXPERIMENTAL | 3 | depends on BLOCK && EXPERIMENTAL |
4 | depends on BKL # need to fix | ||
4 | help | 5 | help |
5 | The Acorn Disc Filing System is the standard file system of the | 6 | The Acorn Disc Filing System is the standard file system of the |
6 | RiscOS operating system which runs on Acorn's ARM-based Risc PC | 7 | RiscOS operating system which runs on Acorn's ARM-based Risc PC |
diff --git a/fs/autofs/Kconfig b/fs/autofs/Kconfig index 5f3bea90911e..480e210c83ab 100644 --- a/fs/autofs/Kconfig +++ b/fs/autofs/Kconfig | |||
@@ -1,5 +1,6 @@ | |||
1 | config AUTOFS_FS | 1 | config AUTOFS_FS |
2 | tristate "Kernel automounter support" | 2 | tristate "Kernel automounter support" |
3 | depends on BKL # unfixable, just use autofs4 | ||
3 | help | 4 | help |
4 | The automounter is a tool to automatically mount remote file systems | 5 | The automounter is a tool to automatically mount remote file systems |
5 | on demand. This implementation is partially kernel-based to reduce | 6 | on demand. This implementation is partially kernel-based to reduce |
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c index 03e59aa318eb..d0ad09d57789 100644 --- a/fs/compat_ioctl.c +++ b/fs/compat_ioctl.c | |||
@@ -599,69 +599,6 @@ static int do_smb_getmountuid(unsigned int fd, unsigned int cmd, | |||
599 | #define HIDPGETCONNLIST _IOR('H', 210, int) | 599 | #define HIDPGETCONNLIST _IOR('H', 210, int) |
600 | #define HIDPGETCONNINFO _IOR('H', 211, int) | 600 | #define HIDPGETCONNINFO _IOR('H', 211, int) |
601 | 601 | ||
602 | #ifdef CONFIG_BLOCK | ||
603 | struct raw32_config_request | ||
604 | { | ||
605 | compat_int_t raw_minor; | ||
606 | __u64 block_major; | ||
607 | __u64 block_minor; | ||
608 | } __attribute__((packed)); | ||
609 | |||
610 | static int get_raw32_request(struct raw_config_request *req, struct raw32_config_request __user *user_req) | ||
611 | { | ||
612 | int ret; | ||
613 | |||
614 | if (!access_ok(VERIFY_READ, user_req, sizeof(struct raw32_config_request))) | ||
615 | return -EFAULT; | ||
616 | |||
617 | ret = __get_user(req->raw_minor, &user_req->raw_minor); | ||
618 | ret |= __get_user(req->block_major, &user_req->block_major); | ||
619 | ret |= __get_user(req->block_minor, &user_req->block_minor); | ||
620 | |||
621 | return ret ? -EFAULT : 0; | ||
622 | } | ||
623 | |||
624 | static int set_raw32_request(struct raw_config_request *req, struct raw32_config_request __user *user_req) | ||
625 | { | ||
626 | int ret; | ||
627 | |||
628 | if (!access_ok(VERIFY_WRITE, user_req, sizeof(struct raw32_config_request))) | ||
629 | return -EFAULT; | ||
630 | |||
631 | ret = __put_user(req->raw_minor, &user_req->raw_minor); | ||
632 | ret |= __put_user(req->block_major, &user_req->block_major); | ||
633 | ret |= __put_user(req->block_minor, &user_req->block_minor); | ||
634 | |||
635 | return ret ? -EFAULT : 0; | ||
636 | } | ||
637 | |||
638 | static int raw_ioctl(unsigned fd, unsigned cmd, | ||
639 | struct raw32_config_request __user *user_req) | ||
640 | { | ||
641 | int ret; | ||
642 | |||
643 | switch (cmd) { | ||
644 | case RAW_SETBIND: | ||
645 | default: { /* RAW_GETBIND */ | ||
646 | struct raw_config_request req; | ||
647 | mm_segment_t oldfs = get_fs(); | ||
648 | |||
649 | if ((ret = get_raw32_request(&req, user_req))) | ||
650 | return ret; | ||
651 | |||
652 | set_fs(KERNEL_DS); | ||
653 | ret = sys_ioctl(fd,cmd,(unsigned long)&req); | ||
654 | set_fs(oldfs); | ||
655 | |||
656 | if ((!ret) && (cmd == RAW_GETBIND)) { | ||
657 | ret = set_raw32_request(&req, user_req); | ||
658 | } | ||
659 | break; | ||
660 | } | ||
661 | } | ||
662 | return ret; | ||
663 | } | ||
664 | #endif /* CONFIG_BLOCK */ | ||
665 | 602 | ||
666 | struct serial_struct32 { | 603 | struct serial_struct32 { |
667 | compat_int_t type; | 604 | compat_int_t type; |
@@ -1262,9 +1199,6 @@ COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE5) | |||
1262 | COMPATIBLE_IOCTL(SOUND_MIXER_GETLEVELS) | 1199 | COMPATIBLE_IOCTL(SOUND_MIXER_GETLEVELS) |
1263 | COMPATIBLE_IOCTL(SOUND_MIXER_SETLEVELS) | 1200 | COMPATIBLE_IOCTL(SOUND_MIXER_SETLEVELS) |
1264 | COMPATIBLE_IOCTL(OSS_GETVERSION) | 1201 | COMPATIBLE_IOCTL(OSS_GETVERSION) |
1265 | /* Raw devices */ | ||
1266 | COMPATIBLE_IOCTL(RAW_SETBIND) | ||
1267 | COMPATIBLE_IOCTL(RAW_GETBIND) | ||
1268 | /* SMB ioctls which do not need any translations */ | 1202 | /* SMB ioctls which do not need any translations */ |
1269 | COMPATIBLE_IOCTL(SMB_IOC_NEWCONN) | 1203 | COMPATIBLE_IOCTL(SMB_IOC_NEWCONN) |
1270 | /* Watchdog */ | 1204 | /* Watchdog */ |
@@ -1523,10 +1457,6 @@ static long do_ioctl_trans(int fd, unsigned int cmd, | |||
1523 | case MTIOCGET32: | 1457 | case MTIOCGET32: |
1524 | case MTIOCPOS32: | 1458 | case MTIOCPOS32: |
1525 | return mt_ioctl_trans(fd, cmd, argp); | 1459 | return mt_ioctl_trans(fd, cmd, argp); |
1526 | /* Raw devices */ | ||
1527 | case RAW_SETBIND: | ||
1528 | case RAW_GETBIND: | ||
1529 | return raw_ioctl(fd, cmd, argp); | ||
1530 | #endif | 1460 | #endif |
1531 | /* One SMB ioctl needs translations. */ | 1461 | /* One SMB ioctl needs translations. */ |
1532 | #define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, compat_uid_t) | 1462 | #define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, compat_uid_t) |
diff --git a/fs/hpfs/Kconfig b/fs/hpfs/Kconfig index 56bd15c5bf6c..63b6f5632318 100644 --- a/fs/hpfs/Kconfig +++ b/fs/hpfs/Kconfig | |||
@@ -1,6 +1,7 @@ | |||
1 | config HPFS_FS | 1 | config HPFS_FS |
2 | tristate "OS/2 HPFS file system support" | 2 | tristate "OS/2 HPFS file system support" |
3 | depends on BLOCK | 3 | depends on BLOCK |
4 | depends on BKL # nontrivial to fix | ||
4 | help | 5 | help |
5 | OS/2 is IBM's operating system for PC's, the same as Warp, and HPFS | 6 | OS/2 is IBM's operating system for PC's, the same as Warp, and HPFS |
6 | is the file system used for organizing files on OS/2 hard disk | 7 | is the file system used for organizing files on OS/2 hard disk |
diff --git a/fs/nfs/Kconfig b/fs/nfs/Kconfig index f7e13db613cb..b950415d7c43 100644 --- a/fs/nfs/Kconfig +++ b/fs/nfs/Kconfig | |||
@@ -1,6 +1,7 @@ | |||
1 | config NFS_FS | 1 | config NFS_FS |
2 | tristate "NFS client support" | 2 | tristate "NFS client support" |
3 | depends on INET && FILE_LOCKING | 3 | depends on INET && FILE_LOCKING |
4 | depends on BKL # fix as soon as lockd is done | ||
4 | select LOCKD | 5 | select LOCKD |
5 | select SUNRPC | 6 | select SUNRPC |
6 | select NFS_ACL_SUPPORT if NFS_V3_ACL | 7 | select NFS_ACL_SUPPORT if NFS_V3_ACL |
diff --git a/fs/nfsd/Kconfig b/fs/nfsd/Kconfig index 4264377552e2..7cf4ddafb4ab 100644 --- a/fs/nfsd/Kconfig +++ b/fs/nfsd/Kconfig | |||
@@ -2,6 +2,7 @@ config NFSD | |||
2 | tristate "NFS server support" | 2 | tristate "NFS server support" |
3 | depends on INET | 3 | depends on INET |
4 | depends on FILE_LOCKING | 4 | depends on FILE_LOCKING |
5 | depends on BKL # fix as soon as lockd is done | ||
5 | select LOCKD | 6 | select LOCKD |
6 | select SUNRPC | 7 | select SUNRPC |
7 | select EXPORTFS | 8 | select EXPORTFS |
diff --git a/fs/smbfs/Kconfig b/fs/smbfs/Kconfig index e668127c8b2e..2bc24a8c4039 100644 --- a/fs/smbfs/Kconfig +++ b/fs/smbfs/Kconfig | |||
@@ -1,5 +1,6 @@ | |||
1 | config SMB_FS | 1 | config SMB_FS |
2 | tristate "SMB file system support (OBSOLETE, please use CIFS)" | 2 | tristate "SMB file system support (OBSOLETE, please use CIFS)" |
3 | depends on BKL # probably unfixable | ||
3 | depends on INET | 4 | depends on INET |
4 | select NLS | 5 | select NLS |
5 | help | 6 | help |
diff --git a/fs/udf/Kconfig b/fs/udf/Kconfig index 0e0e99bd6bce..f8def3c8ea4c 100644 --- a/fs/udf/Kconfig +++ b/fs/udf/Kconfig | |||
@@ -1,5 +1,6 @@ | |||
1 | config UDF_FS | 1 | config UDF_FS |
2 | tristate "UDF file system support" | 2 | tristate "UDF file system support" |
3 | depends on BKL # needs serious work to remove | ||
3 | select CRC_ITU_T | 4 | select CRC_ITU_T |
4 | help | 5 | help |
5 | This is the new file system used on some CD-ROMs and DVDs. Say Y if | 6 | This is the new file system used on some CD-ROMs and DVDs. Say Y if |
diff --git a/fs/ufs/Kconfig b/fs/ufs/Kconfig index e4f10a40768a..30c8f223253d 100644 --- a/fs/ufs/Kconfig +++ b/fs/ufs/Kconfig | |||
@@ -1,6 +1,7 @@ | |||
1 | config UFS_FS | 1 | config UFS_FS |
2 | tristate "UFS file system support (read only)" | 2 | tristate "UFS file system support (read only)" |
3 | depends on BLOCK | 3 | depends on BLOCK |
4 | depends on BKL # probably fixable | ||
4 | help | 5 | help |
5 | BSD and derivate versions of Unix (such as SunOS, FreeBSD, NetBSD, | 6 | BSD and derivate versions of Unix (such as SunOS, FreeBSD, NetBSD, |
6 | OpenBSD and NeXTstep) use a file system called UFS. Some System V | 7 | OpenBSD and NeXTstep) use a file system called UFS. Some System V |
diff --git a/include/linux/smp_lock.h b/include/linux/smp_lock.h index 2ea1dd1ba21c..291f721144c2 100644 --- a/include/linux/smp_lock.h +++ b/include/linux/smp_lock.h | |||
@@ -54,12 +54,15 @@ static inline void cycle_kernel_lock(void) | |||
54 | 54 | ||
55 | #else | 55 | #else |
56 | 56 | ||
57 | #ifdef CONFIG_BKL /* provoke build bug if not set */ | ||
57 | #define lock_kernel() | 58 | #define lock_kernel() |
58 | #define unlock_kernel() | 59 | #define unlock_kernel() |
59 | #define release_kernel_lock(task) do { } while(0) | ||
60 | #define cycle_kernel_lock() do { } while(0) | 60 | #define cycle_kernel_lock() do { } while(0) |
61 | #define reacquire_kernel_lock(task) 0 | ||
62 | #define kernel_locked() 1 | 61 | #define kernel_locked() 1 |
62 | #endif /* CONFIG_BKL */ | ||
63 | |||
64 | #define release_kernel_lock(task) do { } while(0) | ||
65 | #define reacquire_kernel_lock(task) 0 | ||
63 | 66 | ||
64 | #endif /* CONFIG_LOCK_KERNEL */ | 67 | #endif /* CONFIG_LOCK_KERNEL */ |
65 | #endif /* __LINUX_SMPLOCK_H */ | 68 | #endif /* __LINUX_SMPLOCK_H */ |
diff --git a/init/Kconfig b/init/Kconfig index 36890f0c8456..be85a0ab1b82 100644 --- a/init/Kconfig +++ b/init/Kconfig | |||
@@ -71,7 +71,7 @@ config BROKEN_ON_SMP | |||
71 | 71 | ||
72 | config LOCK_KERNEL | 72 | config LOCK_KERNEL |
73 | bool | 73 | bool |
74 | depends on SMP || PREEMPT | 74 | depends on (SMP || PREEMPT) && BKL |
75 | default y | 75 | default y |
76 | 76 | ||
77 | config INIT_ENV_ARG_LIMIT | 77 | config INIT_ENV_ARG_LIMIT |
diff --git a/init/main.c b/init/main.c index 9684c9670b48..e59af24a0b7c 100644 --- a/init/main.c +++ b/init/main.c | |||
@@ -424,7 +424,6 @@ static void __init setup_command_line(char *command_line) | |||
424 | static __initdata DECLARE_COMPLETION(kthreadd_done); | 424 | static __initdata DECLARE_COMPLETION(kthreadd_done); |
425 | 425 | ||
426 | static noinline void __init_refok rest_init(void) | 426 | static noinline void __init_refok rest_init(void) |
427 | __releases(kernel_lock) | ||
428 | { | 427 | { |
429 | int pid; | 428 | int pid; |
430 | 429 | ||
@@ -818,7 +817,6 @@ static void run_init_process(const char *init_filename) | |||
818 | * makes it inline to init() and it becomes part of init.text section | 817 | * makes it inline to init() and it becomes part of init.text section |
819 | */ | 818 | */ |
820 | static noinline int init_post(void) | 819 | static noinline int init_post(void) |
821 | __releases(kernel_lock) | ||
822 | { | 820 | { |
823 | /* need to finish all async __init code before freeing the memory */ | 821 | /* need to finish all async __init code before freeing the memory */ |
824 | async_synchronize_full(); | 822 | async_synchronize_full(); |
diff --git a/kernel/rtmutex-tester.c b/kernel/rtmutex-tester.c index a56f629b057a..66cb89bc5ef1 100644 --- a/kernel/rtmutex-tester.c +++ b/kernel/rtmutex-tester.c | |||
@@ -76,7 +76,9 @@ static int handle_op(struct test_thread_data *td, int lockwakeup) | |||
76 | } | 76 | } |
77 | 77 | ||
78 | if (!lockwakeup && td->bkl == 4) { | 78 | if (!lockwakeup && td->bkl == 4) { |
79 | #ifdef CONFIG_LOCK_KERNEL | ||
79 | unlock_kernel(); | 80 | unlock_kernel(); |
81 | #endif | ||
80 | td->bkl = 0; | 82 | td->bkl = 0; |
81 | } | 83 | } |
82 | return 0; | 84 | return 0; |
@@ -133,14 +135,18 @@ static int handle_op(struct test_thread_data *td, int lockwakeup) | |||
133 | if (td->bkl) | 135 | if (td->bkl) |
134 | return 0; | 136 | return 0; |
135 | td->bkl = 1; | 137 | td->bkl = 1; |
138 | #ifdef CONFIG_LOCK_KERNEL | ||
136 | lock_kernel(); | 139 | lock_kernel(); |
140 | #endif | ||
137 | td->bkl = 4; | 141 | td->bkl = 4; |
138 | return 0; | 142 | return 0; |
139 | 143 | ||
140 | case RTTEST_UNLOCKBKL: | 144 | case RTTEST_UNLOCKBKL: |
141 | if (td->bkl != 4) | 145 | if (td->bkl != 4) |
142 | break; | 146 | break; |
147 | #ifdef CONFIG_LOCK_KERNEL | ||
143 | unlock_kernel(); | 148 | unlock_kernel(); |
149 | #endif | ||
144 | td->bkl = 0; | 150 | td->bkl = 0; |
145 | return 0; | 151 | return 0; |
146 | 152 | ||
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c index 959f8d6c8cc1..5328e8779d4d 100644 --- a/kernel/trace/blktrace.c +++ b/kernel/trace/blktrace.c | |||
@@ -23,7 +23,6 @@ | |||
23 | #include <linux/mutex.h> | 23 | #include <linux/mutex.h> |
24 | #include <linux/slab.h> | 24 | #include <linux/slab.h> |
25 | #include <linux/debugfs.h> | 25 | #include <linux/debugfs.h> |
26 | #include <linux/smp_lock.h> | ||
27 | #include <linux/time.h> | 26 | #include <linux/time.h> |
28 | #include <linux/uaccess.h> | 27 | #include <linux/uaccess.h> |
29 | 28 | ||
@@ -639,7 +638,6 @@ int blk_trace_ioctl(struct block_device *bdev, unsigned cmd, char __user *arg) | |||
639 | if (!q) | 638 | if (!q) |
640 | return -ENXIO; | 639 | return -ENXIO; |
641 | 640 | ||
642 | lock_kernel(); | ||
643 | mutex_lock(&bdev->bd_mutex); | 641 | mutex_lock(&bdev->bd_mutex); |
644 | 642 | ||
645 | switch (cmd) { | 643 | switch (cmd) { |
@@ -667,7 +665,6 @@ int blk_trace_ioctl(struct block_device *bdev, unsigned cmd, char __user *arg) | |||
667 | } | 665 | } |
668 | 666 | ||
669 | mutex_unlock(&bdev->bd_mutex); | 667 | mutex_unlock(&bdev->bd_mutex); |
670 | unlock_kernel(); | ||
671 | return ret; | 668 | return ret; |
672 | } | 669 | } |
673 | 670 | ||
@@ -1652,10 +1649,9 @@ static ssize_t sysfs_blk_trace_attr_show(struct device *dev, | |||
1652 | struct block_device *bdev; | 1649 | struct block_device *bdev; |
1653 | ssize_t ret = -ENXIO; | 1650 | ssize_t ret = -ENXIO; |
1654 | 1651 | ||
1655 | lock_kernel(); | ||
1656 | bdev = bdget(part_devt(p)); | 1652 | bdev = bdget(part_devt(p)); |
1657 | if (bdev == NULL) | 1653 | if (bdev == NULL) |
1658 | goto out_unlock_kernel; | 1654 | goto out; |
1659 | 1655 | ||
1660 | q = blk_trace_get_queue(bdev); | 1656 | q = blk_trace_get_queue(bdev); |
1661 | if (q == NULL) | 1657 | if (q == NULL) |
@@ -1683,8 +1679,7 @@ out_unlock_bdev: | |||
1683 | mutex_unlock(&bdev->bd_mutex); | 1679 | mutex_unlock(&bdev->bd_mutex); |
1684 | out_bdput: | 1680 | out_bdput: |
1685 | bdput(bdev); | 1681 | bdput(bdev); |
1686 | out_unlock_kernel: | 1682 | out: |
1687 | unlock_kernel(); | ||
1688 | return ret; | 1683 | return ret; |
1689 | } | 1684 | } |
1690 | 1685 | ||
@@ -1714,11 +1709,10 @@ static ssize_t sysfs_blk_trace_attr_store(struct device *dev, | |||
1714 | 1709 | ||
1715 | ret = -ENXIO; | 1710 | ret = -ENXIO; |
1716 | 1711 | ||
1717 | lock_kernel(); | ||
1718 | p = dev_to_part(dev); | 1712 | p = dev_to_part(dev); |
1719 | bdev = bdget(part_devt(p)); | 1713 | bdev = bdget(part_devt(p)); |
1720 | if (bdev == NULL) | 1714 | if (bdev == NULL) |
1721 | goto out_unlock_kernel; | 1715 | goto out; |
1722 | 1716 | ||
1723 | q = blk_trace_get_queue(bdev); | 1717 | q = blk_trace_get_queue(bdev); |
1724 | if (q == NULL) | 1718 | if (q == NULL) |
@@ -1753,8 +1747,6 @@ out_unlock_bdev: | |||
1753 | mutex_unlock(&bdev->bd_mutex); | 1747 | mutex_unlock(&bdev->bd_mutex); |
1754 | out_bdput: | 1748 | out_bdput: |
1755 | bdput(bdev); | 1749 | bdput(bdev); |
1756 | out_unlock_kernel: | ||
1757 | unlock_kernel(); | ||
1758 | out: | 1750 | out: |
1759 | return ret ? ret : count; | 1751 | return ret ? ret : count; |
1760 | } | 1752 | } |
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index 21ac83070a80..7b2a8ca97ada 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug | |||
@@ -461,6 +461,15 @@ config DEBUG_MUTEXES | |||
461 | This feature allows mutex semantics violations to be detected and | 461 | This feature allows mutex semantics violations to be detected and |
462 | reported. | 462 | reported. |
463 | 463 | ||
464 | config BKL | ||
465 | bool "Big Kernel Lock" if (SMP || PREEMPT) | ||
466 | default y | ||
467 | help | ||
468 | This is the traditional lock that is used in old code instead | ||
469 | of proper locking. All drivers that use the BKL should depend | ||
470 | on this symbol. | ||
471 | Say Y here unless you are working on removing the BKL. | ||
472 | |||
464 | config DEBUG_LOCK_ALLOC | 473 | config DEBUG_LOCK_ALLOC |
465 | bool "Lock debugging: detect incorrect freeing of live locks" | 474 | bool "Lock debugging: detect incorrect freeing of live locks" |
466 | depends on DEBUG_KERNEL && TRACE_IRQFLAGS_SUPPORT && STACKTRACE_SUPPORT && LOCKDEP_SUPPORT | 475 | depends on DEBUG_KERNEL && TRACE_IRQFLAGS_SUPPORT && STACKTRACE_SUPPORT && LOCKDEP_SUPPORT |
diff --git a/net/ipx/Kconfig b/net/ipx/Kconfig index e9ad0062fbb6..02549cb2c328 100644 --- a/net/ipx/Kconfig +++ b/net/ipx/Kconfig | |||
@@ -3,6 +3,7 @@ | |||
3 | # | 3 | # |
4 | config IPX | 4 | config IPX |
5 | tristate "The IPX protocol" | 5 | tristate "The IPX protocol" |
6 | depends on BKL # should be fixable | ||
6 | select LLC | 7 | select LLC |
7 | ---help--- | 8 | ---help--- |
8 | This is support for the Novell networking protocol, IPX, commonly | 9 | This is support for the Novell networking protocol, IPX, commonly |
diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c index 2b06410e584e..29b11e065015 100644 --- a/net/sunrpc/cache.c +++ b/net/sunrpc/cache.c | |||
@@ -28,7 +28,6 @@ | |||
28 | #include <linux/workqueue.h> | 28 | #include <linux/workqueue.h> |
29 | #include <linux/mutex.h> | 29 | #include <linux/mutex.h> |
30 | #include <linux/pagemap.h> | 30 | #include <linux/pagemap.h> |
31 | #include <linux/smp_lock.h> | ||
32 | #include <asm/ioctls.h> | 31 | #include <asm/ioctls.h> |
33 | #include <linux/sunrpc/types.h> | 32 | #include <linux/sunrpc/types.h> |
34 | #include <linux/sunrpc/cache.h> | 33 | #include <linux/sunrpc/cache.h> |
@@ -1348,15 +1347,10 @@ static unsigned int cache_poll_procfs(struct file *filp, poll_table *wait) | |||
1348 | static long cache_ioctl_procfs(struct file *filp, | 1347 | static long cache_ioctl_procfs(struct file *filp, |
1349 | unsigned int cmd, unsigned long arg) | 1348 | unsigned int cmd, unsigned long arg) |
1350 | { | 1349 | { |
1351 | long ret; | ||
1352 | struct inode *inode = filp->f_path.dentry->d_inode; | 1350 | struct inode *inode = filp->f_path.dentry->d_inode; |
1353 | struct cache_detail *cd = PDE(inode)->data; | 1351 | struct cache_detail *cd = PDE(inode)->data; |
1354 | 1352 | ||
1355 | lock_kernel(); | 1353 | return cache_ioctl(inode, filp, cmd, arg, cd); |
1356 | ret = cache_ioctl(inode, filp, cmd, arg, cd); | ||
1357 | unlock_kernel(); | ||
1358 | |||
1359 | return ret; | ||
1360 | } | 1354 | } |
1361 | 1355 | ||
1362 | static int cache_open_procfs(struct inode *inode, struct file *filp) | 1356 | static int cache_open_procfs(struct inode *inode, struct file *filp) |
@@ -1555,13 +1549,8 @@ static long cache_ioctl_pipefs(struct file *filp, | |||
1555 | { | 1549 | { |
1556 | struct inode *inode = filp->f_dentry->d_inode; | 1550 | struct inode *inode = filp->f_dentry->d_inode; |
1557 | struct cache_detail *cd = RPC_I(inode)->private; | 1551 | struct cache_detail *cd = RPC_I(inode)->private; |
1558 | long ret; | ||
1559 | 1552 | ||
1560 | lock_kernel(); | 1553 | return cache_ioctl(inode, filp, cmd, arg, cd); |
1561 | ret = cache_ioctl(inode, filp, cmd, arg, cd); | ||
1562 | unlock_kernel(); | ||
1563 | |||
1564 | return ret; | ||
1565 | } | 1554 | } |
1566 | 1555 | ||
1567 | static int cache_open_pipefs(struct inode *inode, struct file *filp) | 1556 | static int cache_open_pipefs(struct inode *inode, struct file *filp) |
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c index 8c8eef2b8f26..28bcd52e3ce9 100644 --- a/net/sunrpc/rpc_pipe.c +++ b/net/sunrpc/rpc_pipe.c | |||
@@ -27,7 +27,6 @@ | |||
27 | #include <linux/workqueue.h> | 27 | #include <linux/workqueue.h> |
28 | #include <linux/sunrpc/rpc_pipe_fs.h> | 28 | #include <linux/sunrpc/rpc_pipe_fs.h> |
29 | #include <linux/sunrpc/cache.h> | 29 | #include <linux/sunrpc/cache.h> |
30 | #include <linux/smp_lock.h> | ||
31 | 30 | ||
32 | static struct vfsmount *rpc_mount __read_mostly; | 31 | static struct vfsmount *rpc_mount __read_mostly; |
33 | static int rpc_mount_count; | 32 | static int rpc_mount_count; |
@@ -309,40 +308,33 @@ rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait) | |||
309 | return mask; | 308 | return mask; |
310 | } | 309 | } |
311 | 310 | ||
312 | static int | 311 | static long |
313 | rpc_pipe_ioctl_unlocked(struct file *filp, unsigned int cmd, unsigned long arg) | 312 | rpc_pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) |
314 | { | 313 | { |
315 | struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode); | 314 | struct inode *inode = filp->f_path.dentry->d_inode; |
315 | struct rpc_inode *rpci = RPC_I(inode); | ||
316 | int len; | 316 | int len; |
317 | 317 | ||
318 | switch (cmd) { | 318 | switch (cmd) { |
319 | case FIONREAD: | 319 | case FIONREAD: |
320 | if (rpci->ops == NULL) | 320 | spin_lock(&inode->i_lock); |
321 | if (rpci->ops == NULL) { | ||
322 | spin_unlock(&inode->i_lock); | ||
321 | return -EPIPE; | 323 | return -EPIPE; |
324 | } | ||
322 | len = rpci->pipelen; | 325 | len = rpci->pipelen; |
323 | if (filp->private_data) { | 326 | if (filp->private_data) { |
324 | struct rpc_pipe_msg *msg; | 327 | struct rpc_pipe_msg *msg; |
325 | msg = (struct rpc_pipe_msg *)filp->private_data; | 328 | msg = (struct rpc_pipe_msg *)filp->private_data; |
326 | len += msg->len - msg->copied; | 329 | len += msg->len - msg->copied; |
327 | } | 330 | } |
331 | spin_unlock(&inode->i_lock); | ||
328 | return put_user(len, (int __user *)arg); | 332 | return put_user(len, (int __user *)arg); |
329 | default: | 333 | default: |
330 | return -EINVAL; | 334 | return -EINVAL; |
331 | } | 335 | } |
332 | } | 336 | } |
333 | 337 | ||
334 | static long | ||
335 | rpc_pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) | ||
336 | { | ||
337 | long ret; | ||
338 | |||
339 | lock_kernel(); | ||
340 | ret = rpc_pipe_ioctl_unlocked(filp, cmd, arg); | ||
341 | unlock_kernel(); | ||
342 | |||
343 | return ret; | ||
344 | } | ||
345 | |||
346 | static const struct file_operations rpc_pipe_fops = { | 338 | static const struct file_operations rpc_pipe_fops = { |
347 | .owner = THIS_MODULE, | 339 | .owner = THIS_MODULE, |
348 | .llseek = no_llseek, | 340 | .llseek = no_llseek, |
diff --git a/net/x25/Kconfig b/net/x25/Kconfig index e6759c9660bb..2196e55e4f61 100644 --- a/net/x25/Kconfig +++ b/net/x25/Kconfig | |||
@@ -5,6 +5,7 @@ | |||
5 | config X25 | 5 | config X25 |
6 | tristate "CCITT X.25 Packet Layer (EXPERIMENTAL)" | 6 | tristate "CCITT X.25 Packet Layer (EXPERIMENTAL)" |
7 | depends on EXPERIMENTAL | 7 | depends on EXPERIMENTAL |
8 | depends on BKL # should be fixable | ||
8 | ---help--- | 9 | ---help--- |
9 | X.25 is a set of standardized network protocols, similar in scope to | 10 | X.25 is a set of standardized network protocols, similar in scope to |
10 | frame relay; the one physical line from your box to the X.25 network | 11 | frame relay; the one physical line from your box to the X.25 network |