Commit 4ba8216c authored by Arnd Bergmann's avatar Arnd Bergmann
Browse files

BKL: That's all, folks 



This removes the implementation of the big kernel lock,
at last. A lot of people have worked on this in the
past, I so the credit for this patch should be with
everyone who participated in the hunt.

The names on the Cc list are the people that were the
most active in this, according to the recorded git
history, in alphabetical order.

Signed-off-by: default avatarArnd Bergmann <arnd@arndb.de>
Acked-by: default avatarAlan Cox <alan@linux.intel.com>
Cc: Alessio Igor Bogani <abogani@texware.it>
Cc: Al Viro <viro@zeniv.linux.org.uk>
Cc: Andrew Hendry <andrew.hendry@gmail.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Eric W. Biederman <ebiederm@xmission.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Hans Verkuil <hverkuil@xs4all.nl>
Acked-by: default avatarIngo Molnar <mingo@elte.hu>
Cc: Jan Blunck <jblunck@infradead.org>
Cc: John Kacur <jkacur@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Matthew Wilcox <matthew@wil.cx>
Cc: Oliver Neukum <oliver@neukum.org>
Cc: Paul Menage <menage@google.com>
Acked-by: default avatarThomas Gleixner <tglx@linutronix.de>
Cc: Trond Myklebust <Trond.Myklebust@netapp.com>
parent ae7eb897

include/linux/hardirq.h

+1 −8
Original line number Diff line number Diff line
@@ -93,13 +93,6 @@ 
 */

#define in_nmi()	(preempt_count() & NMI_MASK)



#if defined(CONFIG_PREEMPT) && defined(CONFIG_BKL)

# include <linux/sched.h>

# define PREEMPT_INATOMIC_BASE (current->lock_depth >= 0)

#else

# define PREEMPT_INATOMIC_BASE 0

#endif



#if defined(CONFIG_PREEMPT)

# define PREEMPT_CHECK_OFFSET 1

#else
@@ -113,7 +106,7 @@ 
 * used in the general case to determine whether sleeping is possible.

 * Do not use in_atomic() in driver code.

 */

#define in_atomic()	((preempt_count() & ~PREEMPT_ACTIVE) != PREEMPT_INATOMIC_BASE)

#define in_atomic()	((preempt_count() & ~PREEMPT_ACTIVE) != 0)



/*

 * Check whether we were atomic before we did preempt_disable():

include/linux/smp_lock.h

deleted100644 → 0
+0 −65
Original line number Diff line number Diff line 
#ifndef __LINUX_SMPLOCK_H

#define __LINUX_SMPLOCK_H



#ifdef CONFIG_LOCK_KERNEL

#include <linux/sched.h>



extern int __lockfunc __reacquire_kernel_lock(void);

extern void __lockfunc __release_kernel_lock(void);



/*

 * Release/re-acquire global kernel lock for the scheduler

 */

#define release_kernel_lock(tsk) do { 		\

	if (unlikely((tsk)->lock_depth >= 0))	\

		__release_kernel_lock();	\

} while (0)



static inline int reacquire_kernel_lock(struct task_struct *task)

{

	if (unlikely(task->lock_depth >= 0))

		return __reacquire_kernel_lock();

	return 0;

}



extern void __lockfunc

_lock_kernel(const char *func, const char *file, int line)

__acquires(kernel_lock);



extern void __lockfunc

_unlock_kernel(const char *func, const char *file, int line)

__releases(kernel_lock);



#define lock_kernel() do {					\

	_lock_kernel(__func__, __FILE__, __LINE__);		\

} while (0)



#define unlock_kernel()	do {					\

	_unlock_kernel(__func__, __FILE__, __LINE__);		\

} while (0)



/*

 * Various legacy drivers don't really need the BKL in a specific

 * function, but they *do* need to know that the BKL became available.

 * This function just avoids wrapping a bunch of lock/unlock pairs

 * around code which doesn't really need it.

 */

static inline void cycle_kernel_lock(void)

{

	lock_kernel();

	unlock_kernel();

}



#else



#ifdef CONFIG_BKL /* provoke build bug if not set */

#define lock_kernel()

#define unlock_kernel()

#define cycle_kernel_lock()			do { } while(0)

#endif /* CONFIG_BKL */



#define release_kernel_lock(task)		do { } while(0)

#define reacquire_kernel_lock(task)		0



#endif /* CONFIG_LOCK_KERNEL */

#endif /* __LINUX_SMPLOCK_H */

init/Kconfig

+0 −5
Original line number Diff line number Diff line
@@ -69,11 +69,6 @@ config BROKEN_ON_SMP 
	depends on BROKEN || !SMP

	default y



config LOCK_KERNEL

	bool

	depends on (SMP || PREEMPT) && BKL

	default y



config INIT_ENV_ARG_LIMIT

	int

	default 32 if !UML

kernel/sched.c

+1 −8
Original line number Diff line number Diff line
@@ -32,7 +32,6 @@ 
#include <linux/init.h>

#include <linux/uaccess.h>

#include <linux/highmem.h>

#include <linux/smp_lock.h>

#include <asm/mmu_context.h>

#include <linux/interrupt.h>

#include <linux/capability.h>
@@ -3945,9 +3944,6 @@ need_resched: 
	rcu_note_context_switch(cpu);

	prev = rq->curr;



	release_kernel_lock(prev);

need_resched_nonpreemptible:



	schedule_debug(prev);



	if (sched_feat(HRTICK))
@@ -4010,9 +4006,6 @@ need_resched_nonpreemptible: 


	post_schedule(rq);



	if (unlikely(reacquire_kernel_lock(prev)))

		goto need_resched_nonpreemptible;



	preempt_enable_no_resched();

	if (need_resched())

		goto need_resched;
@@ -8074,7 +8067,7 @@ static inline int preempt_count_equals(int preempt_offset) 
{

	int nested = (preempt_count() & ~PREEMPT_ACTIVE) + rcu_preempt_depth();



	return (nested == PREEMPT_INATOMIC_BASE + preempt_offset);

	return (nested == preempt_offset);

}



void __might_sleep(const char *file, int line, int preempt_offset)

lib/Kconfig.debug

+0 −9
Original line number Diff line number Diff line
@@ -470,15 +470,6 @@ config DEBUG_MUTEXES 
	 This feature allows mutex semantics violations to be detected and

	 reported.



config BKL

	bool "Big Kernel Lock" if (SMP || PREEMPT)

	default y

	help

	  This is the traditional lock that is used in old code instead

	  of proper locking. All drivers that use the BKL should depend

	  on this symbol.

	  Say Y here unless you are working on removing the BKL.



config DEBUG_LOCK_ALLOC

	bool "Lock debugging: detect incorrect freeing of live locks"

	depends on DEBUG_KERNEL && TRACE_IRQFLAGS_SUPPORT && STACKTRACE_SUPPORT && LOCKDEP_SUPPORT

CRA Git | Maintained and supported by SUSTech CRA and CCSE