kernel26-2.6.12-alx-r9/lib/kernel_lock.c

/*
 * lib/kernel_lock.c
 *
 * This is the traditional BKL - big kernel lock. Largely
 * relegated to obsolescense, but used by various less
 * important (or lazy) subsystems.
 */
#include <linux/smp_lock.h>
#include <linux/module.h>
#include <linux/kallsyms.h>

#if defined(CONFIG_PREEMPT) && defined(__smp_processor_id) && \
		defined(CONFIG_DEBUG_PREEMPT)

/*
 * Debugging check.
 */
unsigned int smp_processor_id(void)
{
	unsigned long preempt_count = preempt_count();
	int this_cpu = __smp_processor_id();
	cpumask_t this_mask;

	if (likely(preempt_count))
		goto out;

	if (irqs_disabled())
		goto out;

	/*
	 * Kernel threads bound to a single CPU can safely use
	 * smp_processor_id():
	 */
	this_mask = cpumask_of_cpu(this_cpu);

	if (cpus_equal(current->cpus_allowed, this_mask))
		goto out;

	/*
	 * It is valid to assume CPU-locality during early bootup:
	 */
	if (system_state != SYSTEM_RUNNING)
		goto out;

	/*
	 * Avoid recursion:
	 */
	preempt_disable();

	if (!printk_ratelimit())
		goto out_enable;

	printk(KERN_ERR "BUG: using smp_processor_id() in preemptible [%08x] code: %s/%d\n", preempt_count(), current->comm, current->pid);
	print_symbol("caller is %s\n", (long)__builtin_return_address(0));
	dump_stack();

out_enable:
	preempt_enable_no_resched();
out:
	return this_cpu;
}

EXPORT_SYMBOL(smp_processor_id);

#endif /* PREEMPT && __smp_processor_id && DEBUG_PREEMPT */

#ifdef CONFIG_PREEMPT_BKL
/*
 * The 'big kernel semaphore'
 *
 * This mutex is taken and released recursively by lock_kernel()
 * and unlock_kernel().  It is transparently dropped and reaquired
 * over schedule().  It is used to protect legacy code that hasn't
 * been migrated to a proper locking design yet.
 *
 * Note: code locked by this semaphore will only be serialized against
 * other code using the same locking facility. The code guarantees that
 * the task remains on the same CPU.
 *
 * Don't use in new code.
 */
static DECLARE_MUTEX(kernel_sem);

/*
 * Re-acquire the kernel semaphore.
 *
 * This function is called with preemption off.
 *
 * We are executing in schedule() so the code must be extremely careful
 * about recursion, both due to the down() and due to the enabling of
 * preemption. schedule() will re-check the preemption flag after
 * reacquiring the semaphore.
 */
int __lockfunc __reacquire_kernel_lock(void)
{
	struct task_struct *task = current;
	int saved_lock_depth = task->lock_depth;

	BUG_ON(saved_lock_depth < 0);

	task->lock_depth = -1;
	preempt_enable_no_resched();

	down(&kernel_sem);

	preempt_disable();
	task->lock_depth = saved_lock_depth;

	return 0;
}

void __lockfunc __release_kernel_lock(void)
{
	up(&kernel_sem);
}

/*
 * Getting the big kernel semaphore.
 */
void __lockfunc lock_kernel(void)
{
	struct task_struct *task = current;
	int depth = task->lock_depth + 1;

	if (likely(!depth))
		/*
		 * No recursion worries - we set up lock_depth _after_
		 */
		down(&kernel_sem);

	task->lock_depth = depth;
}

void __lockfunc unlock_kernel(void)
{
	struct task_struct *task = current;

	BUG_ON(task->lock_depth < 0);

	if (likely(--task->lock_depth < 0))
		up(&kernel_sem);
}

#else

/*
 * The 'big kernel lock'
 *
 * This spinlock is taken and released recursively by lock_kernel()
 * and unlock_kernel().  It is transparently dropped and reaquired
 * over schedule().  It is used to protect legacy code that hasn't
 * been migrated to a proper locking design yet.
 *
 * Don't use in new code.
 */
static  __cacheline_aligned_in_smp DEFINE_SPINLOCK(kernel_flag);


/*
 * Acquire/release the underlying lock from the scheduler.
 *
 * This is called with preemption disabled, and should
 * return an error value if it cannot get the lock and
 * TIF_NEED_RESCHED gets set.
 *
 * If it successfully gets the lock, it should increment
 * the preemption count like any spinlock does.
 *
 * (This works on UP too - _raw_spin_trylock will never
 * return false in that case)
 */
int __lockfunc __reacquire_kernel_lock(void)
{
	while (!_raw_spin_trylock(&kernel_flag)) {
		if (test_thread_flag(TIF_NEED_RESCHED))
			return -EAGAIN;
		cpu_relax();
	}
	preempt_disable();
	return 0;
}

void __lockfunc __release_kernel_lock(void)
{
	_raw_spin_unlock(&kernel_flag);
	preempt_enable_no_resched();
}

/*
 * These are the BKL spinlocks - we try to be polite about preemption. 
 * If SMP is not on (ie UP preemption), this all goes away because the
 * _raw_spin_trylock() will always succeed.
 */
#ifdef CONFIG_PREEMPT
static inline void __lock_kernel(void)
{
	preempt_disable();
	if (unlikely(!_raw_spin_trylock(&kernel_flag))) {
		/*
		 * If preemption was disabled even before this
		 * was called, there's nothing we can be polite
		 * about - just spin.
		 */
		if (preempt_count() > 1) {
			_raw_spin_lock(&kernel_flag);
			return;
		}

		/*
		 * Otherwise, let's wait for the kernel lock
		 * with preemption enabled..
		 */
		do {
			preempt_enable();
			while (spin_is_locked(&kernel_flag))
				cpu_relax();
			preempt_disable();
		} while (!_raw_spin_trylock(&kernel_flag));
	}
}

#else

/*
 * Non-preemption case - just get the spinlock
 */
static inline void __lock_kernel(void)
{
	_raw_spin_lock(&kernel_flag);
}
#endif

static inline void __unlock_kernel(void)
{
	_raw_spin_unlock(&kernel_flag);
	preempt_enable();
}

/*
 * Getting the big kernel lock.
 *
 * This cannot happen asynchronously, so we only need to
 * worry about other CPU's.
 */
void __lockfunc lock_kernel(void)
{
	int depth = current->lock_depth+1;
	if (likely(!depth))
		__lock_kernel();
	current->lock_depth = depth;
}

void __lockfunc unlock_kernel(void)
{
	BUG_ON(current->lock_depth < 0);
	if (likely(--current->lock_depth < 0))
		__unlock_kernel();
}

#endif

EXPORT_SYMBOL(lock_kernel);
EXPORT_SYMBOL(unlock_kernel);

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