Linux-2.6.12-rc2
[linux-3.10.git] / lib / kernel_lock.c
1 /*
2  * lib/kernel_lock.c
3  *
4  * This is the traditional BKL - big kernel lock. Largely
5  * relegated to obsolescense, but used by various less
6  * important (or lazy) subsystems.
7  */
8 #include <linux/smp_lock.h>
9 #include <linux/module.h>
10 #include <linux/kallsyms.h>
11
12 #if defined(CONFIG_PREEMPT) && defined(__smp_processor_id) && \
13                 defined(CONFIG_DEBUG_PREEMPT)
14
15 /*
16  * Debugging check.
17  */
18 unsigned int smp_processor_id(void)
19 {
20         unsigned long preempt_count = preempt_count();
21         int this_cpu = __smp_processor_id();
22         cpumask_t this_mask;
23
24         if (likely(preempt_count))
25                 goto out;
26
27         if (irqs_disabled())
28                 goto out;
29
30         /*
31          * Kernel threads bound to a single CPU can safely use
32          * smp_processor_id():
33          */
34         this_mask = cpumask_of_cpu(this_cpu);
35
36         if (cpus_equal(current->cpus_allowed, this_mask))
37                 goto out;
38
39         /*
40          * It is valid to assume CPU-locality during early bootup:
41          */
42         if (system_state != SYSTEM_RUNNING)
43                 goto out;
44
45         /*
46          * Avoid recursion:
47          */
48         preempt_disable();
49
50         if (!printk_ratelimit())
51                 goto out_enable;
52
53         printk(KERN_ERR "BUG: using smp_processor_id() in preemptible [%08x] code: %s/%d\n", preempt_count(), current->comm, current->pid);
54         print_symbol("caller is %s\n", (long)__builtin_return_address(0));
55         dump_stack();
56
57 out_enable:
58         preempt_enable_no_resched();
59 out:
60         return this_cpu;
61 }
62
63 EXPORT_SYMBOL(smp_processor_id);
64
65 #endif /* PREEMPT && __smp_processor_id && DEBUG_PREEMPT */
66
67 #ifdef CONFIG_PREEMPT_BKL
68 /*
69  * The 'big kernel semaphore'
70  *
71  * This mutex is taken and released recursively by lock_kernel()
72  * and unlock_kernel().  It is transparently dropped and reaquired
73  * over schedule().  It is used to protect legacy code that hasn't
74  * been migrated to a proper locking design yet.
75  *
76  * Note: code locked by this semaphore will only be serialized against
77  * other code using the same locking facility. The code guarantees that
78  * the task remains on the same CPU.
79  *
80  * Don't use in new code.
81  */
82 static DECLARE_MUTEX(kernel_sem);
83
84 /*
85  * Re-acquire the kernel semaphore.
86  *
87  * This function is called with preemption off.
88  *
89  * We are executing in schedule() so the code must be extremely careful
90  * about recursion, both due to the down() and due to the enabling of
91  * preemption. schedule() will re-check the preemption flag after
92  * reacquiring the semaphore.
93  */
94 int __lockfunc __reacquire_kernel_lock(void)
95 {
96         struct task_struct *task = current;
97         int saved_lock_depth = task->lock_depth;
98
99         BUG_ON(saved_lock_depth < 0);
100
101         task->lock_depth = -1;
102         preempt_enable_no_resched();
103
104         down(&kernel_sem);
105
106         preempt_disable();
107         task->lock_depth = saved_lock_depth;
108
109         return 0;
110 }
111
112 void __lockfunc __release_kernel_lock(void)
113 {
114         up(&kernel_sem);
115 }
116
117 /*
118  * Getting the big kernel semaphore.
119  */
120 void __lockfunc lock_kernel(void)
121 {
122         struct task_struct *task = current;
123         int depth = task->lock_depth + 1;
124
125         if (likely(!depth))
126                 /*
127                  * No recursion worries - we set up lock_depth _after_
128                  */
129                 down(&kernel_sem);
130
131         task->lock_depth = depth;
132 }
133
134 void __lockfunc unlock_kernel(void)
135 {
136         struct task_struct *task = current;
137
138         BUG_ON(task->lock_depth < 0);
139
140         if (likely(--task->lock_depth < 0))
141                 up(&kernel_sem);
142 }
143
144 #else
145
146 /*
147  * The 'big kernel lock'
148  *
149  * This spinlock is taken and released recursively by lock_kernel()
150  * and unlock_kernel().  It is transparently dropped and reaquired
151  * over schedule().  It is used to protect legacy code that hasn't
152  * been migrated to a proper locking design yet.
153  *
154  * Don't use in new code.
155  */
156 static  __cacheline_aligned_in_smp DEFINE_SPINLOCK(kernel_flag);
157
158
159 /*
160  * Acquire/release the underlying lock from the scheduler.
161  *
162  * This is called with preemption disabled, and should
163  * return an error value if it cannot get the lock and
164  * TIF_NEED_RESCHED gets set.
165  *
166  * If it successfully gets the lock, it should increment
167  * the preemption count like any spinlock does.
168  *
169  * (This works on UP too - _raw_spin_trylock will never
170  * return false in that case)
171  */
172 int __lockfunc __reacquire_kernel_lock(void)
173 {
174         while (!_raw_spin_trylock(&kernel_flag)) {
175                 if (test_thread_flag(TIF_NEED_RESCHED))
176                         return -EAGAIN;
177                 cpu_relax();
178         }
179         preempt_disable();
180         return 0;
181 }
182
183 void __lockfunc __release_kernel_lock(void)
184 {
185         _raw_spin_unlock(&kernel_flag);
186         preempt_enable_no_resched();
187 }
188
189 /*
190  * These are the BKL spinlocks - we try to be polite about preemption. 
191  * If SMP is not on (ie UP preemption), this all goes away because the
192  * _raw_spin_trylock() will always succeed.
193  */
194 #ifdef CONFIG_PREEMPT
195 static inline void __lock_kernel(void)
196 {
197         preempt_disable();
198         if (unlikely(!_raw_spin_trylock(&kernel_flag))) {
199                 /*
200                  * If preemption was disabled even before this
201                  * was called, there's nothing we can be polite
202                  * about - just spin.
203                  */
204                 if (preempt_count() > 1) {
205                         _raw_spin_lock(&kernel_flag);
206                         return;
207                 }
208
209                 /*
210                  * Otherwise, let's wait for the kernel lock
211                  * with preemption enabled..
212                  */
213                 do {
214                         preempt_enable();
215                         while (spin_is_locked(&kernel_flag))
216                                 cpu_relax();
217                         preempt_disable();
218                 } while (!_raw_spin_trylock(&kernel_flag));
219         }
220 }
221
222 #else
223
224 /*
225  * Non-preemption case - just get the spinlock
226  */
227 static inline void __lock_kernel(void)
228 {
229         _raw_spin_lock(&kernel_flag);
230 }
231 #endif
232
233 static inline void __unlock_kernel(void)
234 {
235         _raw_spin_unlock(&kernel_flag);
236         preempt_enable();
237 }
238
239 /*
240  * Getting the big kernel lock.
241  *
242  * This cannot happen asynchronously, so we only need to
243  * worry about other CPU's.
244  */
245 void __lockfunc lock_kernel(void)
246 {
247         int depth = current->lock_depth+1;
248         if (likely(!depth))
249                 __lock_kernel();
250         current->lock_depth = depth;
251 }
252
253 void __lockfunc unlock_kernel(void)
254 {
255         BUG_ON(current->lock_depth < 0);
256         if (likely(--current->lock_depth < 0))
257                 __unlock_kernel();
258 }
259
260 #endif
261
262 EXPORT_SYMBOL(lock_kernel);
263 EXPORT_SYMBOL(unlock_kernel);
264