925936ebf3
Currently we are calling the bkl tracepoint callbacks just before the bkl lock/unlock operations, ie the tracepoint call is not inside a lock_kernel() function but inside a lock_kernel() macro. Hence the bkl trace event header must be included from smp_lock.h. This raises some nasty circular header dependencies: linux/smp_lock.h -> trace/events/bkl.h -> trace/define_trace.h -> trace/ftrace.h -> linux/ftrace_event.h -> linux/hardirq.h -> linux/smp_lock.h This results in incomplete event declarations, spurious event definitions and other kind of funny behaviours. This is hardly fixable without ugly workarounds. So instead, we push the file name, line number and function name as lock_kernel() parameters, so that we only deal with the trace event header from lib/kernel_lock.c This adds two parameters to lock_kernel() and unlock_kernel() but it should be fine wrt to performances because this pair dos not seem to be called in fast paths. Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com> Cc: Steven Rostedt <rostedt@goodmis.org> Cc: Ingo Molnar <mingo@elte.hu> Cc: Li Zefan <lizf@cn.fujitsu.com>
66 lines
1.6 KiB
C
66 lines
1.6 KiB
C
#ifndef __LINUX_SMPLOCK_H
|
|
#define __LINUX_SMPLOCK_H
|
|
|
|
#ifdef CONFIG_LOCK_KERNEL
|
|
#include <linux/sched.h>
|
|
|
|
#define kernel_locked() (current->lock_depth >= 0)
|
|
|
|
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
|
|
|
|
#define lock_kernel()
|
|
#define unlock_kernel()
|
|
#define release_kernel_lock(task) do { } while(0)
|
|
#define cycle_kernel_lock() do { } while(0)
|
|
#define reacquire_kernel_lock(task) 0
|
|
#define kernel_locked() 1
|
|
|
|
#endif /* CONFIG_LOCK_KERNEL */
|
|
#endif /* __LINUX_SMPLOCK_H */
|