Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e966eaee authored by Ingo Molnar's avatar Ingo Molnar
Browse files

locking/lockdep: Remove the cross-release locking checks 



This code (CONFIG_LOCKDEP_CROSSRELEASE=y and CONFIG_LOCKDEP_COMPLETIONS=y),
while it found a number of old bugs initially, was also causing too many
false positives that caused people to disable lockdep - which is arguably
a worse overall outcome.

If we disable cross-release by default but keep the code upstream then
in practice the most likely outcome is that we'll allow the situation
to degrade gradually, by allowing entropy to introduce more and more
false positives, until it overwhelms maintenance capacity.

Another bad side effect was that people were trying to work around
the false positives by uglifying/complicating unrelated code. There's
a marked difference between annotating locking operations and
uglifying good code just due to bad lock debugging code ...

This gradual decrease in quality happened to a number of debugging
facilities in the kernel, and lockdep is pretty complex already,
so we cannot risk this outcome.

Either cross-release checking can be done right with no false positives,
or it should not be included in the upstream kernel.

( Note that it might make sense to maintain it out of tree and go through
  the false positives every now and then and see whether new bugs were
  introduced. )

Cc: Byungchul Park <byungchul.park@lge.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parent d89c7035

Documentation/locking/crossrelease.txt

deleted100644 → 0
+0 −874

File deleted.

Preview size limit exceeded, changes collapsed.

include/linux/completion.h

+0 −45
Original line number Diff line number Diff line
@@ -10,9 +10,6 @@ 
 */



#include <linux/wait.h>

#ifdef CONFIG_LOCKDEP_COMPLETIONS

#include <linux/lockdep.h>

#endif



/*

 * struct completion - structure used to maintain state for a "completion"
@@ -29,58 +26,16 @@ 
struct completion {

	unsigned int done;

	wait_queue_head_t wait;

#ifdef CONFIG_LOCKDEP_COMPLETIONS

	struct lockdep_map_cross map;

#endif

};



#ifdef CONFIG_LOCKDEP_COMPLETIONS

static inline void complete_acquire(struct completion *x)

{

	lock_acquire_exclusive((struct lockdep_map *)&x->map, 0, 0, NULL, _RET_IP_);

}



static inline void complete_release(struct completion *x)

{

	lock_release((struct lockdep_map *)&x->map, 0, _RET_IP_);

}



static inline void complete_release_commit(struct completion *x)

{

	lock_commit_crosslock((struct lockdep_map *)&x->map);

}



#define init_completion_map(x, m)					\

do {									\

	lockdep_init_map_crosslock((struct lockdep_map *)&(x)->map,	\

			(m)->name, (m)->key, 0);				\

	__init_completion(x);						\

} while (0)



#define init_completion(x)						\

do {									\

	static struct lock_class_key __key;				\

	lockdep_init_map_crosslock((struct lockdep_map *)&(x)->map,	\

			"(completion)" #x,				\

			&__key, 0);					\

	__init_completion(x);						\

} while (0)

#else

#define init_completion_map(x, m) __init_completion(x)

#define init_completion(x) __init_completion(x)

static inline void complete_acquire(struct completion *x) {}

static inline void complete_release(struct completion *x) {}

static inline void complete_release_commit(struct completion *x) {}

#endif



#ifdef CONFIG_LOCKDEP_COMPLETIONS

#define COMPLETION_INITIALIZER(work) \

	{ 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait), \

	STATIC_CROSS_LOCKDEP_MAP_INIT("(completion)" #work, &(work)) }

#else

#define COMPLETION_INITIALIZER(work) \

	{ 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) }

#endif



#define COMPLETION_INITIALIZER_ONSTACK_MAP(work, map) \

	(*({ init_completion_map(&(work), &(map)); &(work); }))

include/linux/lockdep.h

+0 −125
Original line number Diff line number Diff line
@@ -158,12 +158,6 @@ struct lockdep_map { 
	int				cpu;

	unsigned long			ip;

#endif

#ifdef CONFIG_LOCKDEP_CROSSRELEASE

	/*

	 * Whether it's a crosslock.

	 */

	int				cross;

#endif

};



static inline void lockdep_copy_map(struct lockdep_map *to,
@@ -267,95 +261,8 @@ struct held_lock { 
	unsigned int hardirqs_off:1;

	unsigned int references:12;					/* 32 bits */

	unsigned int pin_count;

#ifdef CONFIG_LOCKDEP_CROSSRELEASE

	/*

	 * Generation id.

	 *

	 * A value of cross_gen_id will be stored when holding this,

	 * which is globally increased whenever each crosslock is held.

	 */

	unsigned int gen_id;

#endif

};



#ifdef CONFIG_LOCKDEP_CROSSRELEASE

#define MAX_XHLOCK_TRACE_ENTRIES 5



/*

 * This is for keeping locks waiting for commit so that true dependencies

 * can be added at commit step.

 */

struct hist_lock {

	/*

	 * Id for each entry in the ring buffer. This is used to

	 * decide whether the ring buffer was overwritten or not.

	 *

	 * For example,

	 *

	 *           |<----------- hist_lock ring buffer size ------->|

	 *           pppppppppppppppppppppiiiiiiiiiiiiiiiiiiiiiiiiiiiii

	 * wrapped > iiiiiiiiiiiiiiiiiiiiiiiiiii.......................

	 *

	 *           where 'p' represents an acquisition in process

	 *           context, 'i' represents an acquisition in irq

	 *           context.

	 *

	 * In this example, the ring buffer was overwritten by

	 * acquisitions in irq context, that should be detected on

	 * rollback or commit.

	 */

	unsigned int hist_id;



	/*

	 * Seperate stack_trace data. This will be used at commit step.

	 */

	struct stack_trace	trace;

	unsigned long		trace_entries[MAX_XHLOCK_TRACE_ENTRIES];



	/*

	 * Seperate hlock instance. This will be used at commit step.

	 *

	 * TODO: Use a smaller data structure containing only necessary

	 * data. However, we should make lockdep code able to handle the

	 * smaller one first.

	 */

	struct held_lock	hlock;

};



/*

 * To initialize a lock as crosslock, lockdep_init_map_crosslock() should

 * be called instead of lockdep_init_map().

 */

struct cross_lock {

	/*

	 * When more than one acquisition of crosslocks are overlapped,

	 * we have to perform commit for them based on cross_gen_id of

	 * the first acquisition, which allows us to add more true

	 * dependencies.

	 *

	 * Moreover, when no acquisition of a crosslock is in progress,

	 * we should not perform commit because the lock might not exist

	 * any more, which might cause incorrect memory access. So we

	 * have to track the number of acquisitions of a crosslock.

	 */

	int nr_acquire;



	/*

	 * Seperate hlock instance. This will be used at commit step.

	 *

	 * TODO: Use a smaller data structure containing only necessary

	 * data. However, we should make lockdep code able to handle the

	 * smaller one first.

	 */

	struct held_lock	hlock;

};



struct lockdep_map_cross {

	struct lockdep_map map;

	struct cross_lock xlock;

};

#endif



/*

 * Initialization, self-test and debugging-output methods:

 */
@@ -560,37 +467,6 @@ enum xhlock_context_t { 
	XHLOCK_CTX_NR,

};



#ifdef CONFIG_LOCKDEP_CROSSRELEASE

extern void lockdep_init_map_crosslock(struct lockdep_map *lock,

				       const char *name,

				       struct lock_class_key *key,

				       int subclass);

extern void lock_commit_crosslock(struct lockdep_map *lock);



/*

 * What we essencially have to initialize is 'nr_acquire'. Other members

 * will be initialized in add_xlock().

 */

#define STATIC_CROSS_LOCK_INIT() \

	{ .nr_acquire = 0,}



#define STATIC_CROSS_LOCKDEP_MAP_INIT(_name, _key) \

	{ .map.name = (_name), .map.key = (void *)(_key), \

	  .map.cross = 1, .xlock = STATIC_CROSS_LOCK_INIT(), }



/*

 * To initialize a lockdep_map statically use this macro.

 * Note that _name must not be NULL.

 */

#define STATIC_LOCKDEP_MAP_INIT(_name, _key) \

	{ .name = (_name), .key = (void *)(_key), .cross = 0, }



extern void crossrelease_hist_start(enum xhlock_context_t c);

extern void crossrelease_hist_end(enum xhlock_context_t c);

extern void lockdep_invariant_state(bool force);

extern void lockdep_init_task(struct task_struct *task);

extern void lockdep_free_task(struct task_struct *task);

#else /* !CROSSRELEASE */

#define lockdep_init_map_crosslock(m, n, k, s) do {} while (0)

/*

 * To initialize a lockdep_map statically use this macro.
@@ -604,7 +480,6 @@ static inline void crossrelease_hist_end(enum xhlock_context_t c) {} 
static inline void lockdep_invariant_state(bool force) {}

static inline void lockdep_init_task(struct task_struct *task) {}

static inline void lockdep_free_task(struct task_struct *task) {}

#endif /* CROSSRELEASE */



#ifdef CONFIG_LOCK_STAT

include/linux/sched.h

+0 −11
Original line number Diff line number Diff line
@@ -849,17 +849,6 @@ struct task_struct { 
	struct held_lock		held_locks[MAX_LOCK_DEPTH];

#endif



#ifdef CONFIG_LOCKDEP_CROSSRELEASE

#define MAX_XHLOCKS_NR 64UL

	struct hist_lock *xhlocks; /* Crossrelease history locks */

	unsigned int xhlock_idx;

	/* For restoring at history boundaries */

	unsigned int xhlock_idx_hist[XHLOCK_CTX_NR];

	unsigned int hist_id;

	/* For overwrite check at each context exit */

	unsigned int hist_id_save[XHLOCK_CTX_NR];

#endif



#ifdef CONFIG_UBSAN

	unsigned int			in_ubsan;

#endif

kernel/locking/lockdep.c

+35 −617

File changed.

Preview size limit exceeded, changes collapsed.