BKL（大内核锁）

 BKL（大内核锁）是一个全局自旋锁，使用它主要是为了方便实现从Linux最初的SMP过度到细粒度加锁机制。

 BKL的特性：

持有BKL的任务仍然可以睡眠 。因为当任务无法调度时，所加的锁会自动被抛弃；当任务被调度时，锁又会被重新获得。当然，并不是说，当任务持有BKL时，睡眠是安全的，紧急是可以这样做，因为睡眠不会造成任务死锁。

BKL是一种递归锁。一个进程可以多次请求一个锁，并不会像自旋锁那么产生死锁。

BKL可以在进程上下文中。

BKL是有害的。

在内核中不鼓励使用BKL。一个执行线程可以递归的请求锁lock_kernel()，但是释放锁时也必须调用同样次数的unlock_kernel()操作，在最后一个解锁操作完成之后，锁才会被释放。

 

1. 在Kernel_lock.c(lib)中
3. /*
4.  * These are the BKL spinlocks - we try to be polite about preemption. 
5.  * If SMP is not on (ie UP preemption), this all goes away because the
6.  * _raw_spin_trylock() will always succeed.
7.  */
8. #ifdef CONFIG_PREEMPT
9. static inline void __lock_kernel(void)
10. {
11.     preempt_disable();
12.     if (unlikely(!_raw_spin_trylock(&kernel_flag))) {
13.         /*
14.          * If preemption was disabled even before this
15.          * was called, there's nothing we can be polite
16.          * about - just spin.
17.          */
18.         if (preempt_count() > 1) {
19.             _raw_spin_lock(&kernel_flag);
20.             return;
21.         }
23.         /*
24.          * Otherwise, let's wait for the kernel lock
25.          * with preemption enabled..
26.          */
27.         do {
28.             preempt_enable();
29.             while (spin_is_locked(&kernel_flag))
30.                 cpu_relax();
31.             preempt_disable();
32.         } while (!_raw_spin_trylock(&kernel_flag));
33.     }
34. }
36. #else
38. /*
39.  * Non-preemption case - just get the spinlock
40.  */
41. static inline void __lock_kernel(void)
42. {
43.     _raw_spin_lock(&kernel_flag);
44. }
45. #endif
47. static inline void __unlock_kernel(void)
48. {
49.     /*
50.      * the BKL is not covered by lockdep, so we open-code the
51.      * unlocking sequence (and thus avoid the dep-chain ops):
52.      */
53.     _raw_spin_unlock(&kernel_flag);
54.     preempt_enable();
55. }
57. /*
58.  * Getting the big kernel lock.
59.  *
60.  * This cannot happen asynchronously, so we only need to
61.  * worry about other CPU's.
62.  */
63. void __lockfunc lock_kernel(void)
64. {
65.     int depth = current->lock_depth+1;
66.     if (likely(!depth))
67.         __lock_kernel();
68.     current->lock_depth = depth;
69. }
71. void __lockfunc unlock_kernel(void)
72. {
73.     BUG_ON(current->lock_depth < 0);
74.     if (likely(--current->lock_depth < 0))
75.         __unlock_kernel();
76. }

BKL在被持有时同样会禁止内核抢占。多数情况下，BKL更像是保护代码而不是保护数据。