Commit 3454a36d authored by Boqun Feng's avatar Boqun Feng Committed by Peter Zijlstra
Browse files

lockdep: Introduce lock_list::dep 



To add recursive read locks into the dependency graph, we need to store
the types of dependencies for the BFS later. There are four types of
dependencies:

*	Exclusive -> Non-recursive dependencies: EN
	e.g. write_lock(prev) held and try to acquire write_lock(next)
	or non-recursive read_lock(next), which can be represented as
	"prev -(EN)-> next"

*	Shared -> Non-recursive dependencies: SN
	e.g. read_lock(prev) held and try to acquire write_lock(next) or
	non-recursive read_lock(next), which can be represented as
	"prev -(SN)-> next"

*	Exclusive -> Recursive dependencies: ER
	e.g. write_lock(prev) held and try to acquire recursive
	read_lock(next), which can be represented as "prev -(ER)-> next"

*	Shared -> Recursive dependencies: SR
	e.g. read_lock(prev) held and try to acquire recursive
	read_lock(next), which can be represented as "prev -(SR)-> next"

So we use 4 bits for the presence of each type in lock_list::dep. Helper
functions and macros are also introduced to convert a pair of locks into
lock_list::dep bit and maintain the addition of different types of
dependencies.

Signed-off-by: default avatarBoqun Feng <boqun.feng@gmail.com>
Signed-off-by: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Link: https://lkml.kernel.org/r/20200807074238.1632519-7-boqun.feng@gmail.com
parent bd76eca1

include/linux/lockdep.h

+2 −0
Original line number Diff line number Diff line
@@ -55,6 +55,8 @@ struct lock_list { 
	struct lock_class		*links_to;

	const struct lock_trace		*trace;

	u16				distance;

	/* bitmap of different dependencies from head to this */

	u8				dep;



	/*

	 * The parent field is used to implement breadth-first search, and the

kernel/locking/lockdep.c

+88 −4
Original line number Diff line number Diff line
@@ -1320,7 +1320,7 @@ static struct lock_list *alloc_list_entry(void) 
 */

static int add_lock_to_list(struct lock_class *this,

			    struct lock_class *links_to, struct list_head *head,

			    unsigned long ip, u16 distance,

			    unsigned long ip, u16 distance, u8 dep,

			    const struct lock_trace *trace)

{

	struct lock_list *entry;
@@ -1334,6 +1334,7 @@ static int add_lock_to_list(struct lock_class *this, 


	entry->class = this;

	entry->links_to = links_to;

	entry->dep = dep;

	entry->distance = distance;

	entry->trace = trace;

	/*
@@ -1498,6 +1499,57 @@ static inline bool bfs_error(enum bfs_result res) 
	return res < 0;

}



/*

 * DEP_*_BIT in lock_list::dep

 *

 * For dependency @prev -> @next:

 *

 *   SR: @prev is shared reader (->read != 0) and @next is recursive reader

 *       (->read == 2)

 *   ER: @prev is exclusive locker (->read == 0) and @next is recursive reader

 *   SN: @prev is shared reader and @next is non-recursive locker (->read != 2)

 *   EN: @prev is exclusive locker and @next is non-recursive locker

 *

 * Note that we define the value of DEP_*_BITs so that:

 *   bit0 is prev->read == 0

 *   bit1 is next->read != 2

 */

#define DEP_SR_BIT (0 + (0 << 1)) /* 0 */

#define DEP_ER_BIT (1 + (0 << 1)) /* 1 */

#define DEP_SN_BIT (0 + (1 << 1)) /* 2 */

#define DEP_EN_BIT (1 + (1 << 1)) /* 3 */



#define DEP_SR_MASK (1U << (DEP_SR_BIT))

#define DEP_ER_MASK (1U << (DEP_ER_BIT))

#define DEP_SN_MASK (1U << (DEP_SN_BIT))

#define DEP_EN_MASK (1U << (DEP_EN_BIT))



static inline unsigned int

__calc_dep_bit(struct held_lock *prev, struct held_lock *next)

{

	return (prev->read == 0) + ((next->read != 2) << 1);

}



static inline u8 calc_dep(struct held_lock *prev, struct held_lock *next)

{

	return 1U << __calc_dep_bit(prev, next);

}



/*

 * calculate the dep_bit for backwards edges. We care about whether @prev is

 * shared and whether @next is recursive.

 */

static inline unsigned int

__calc_dep_bitb(struct held_lock *prev, struct held_lock *next)

{

	return (next->read != 2) + ((prev->read == 0) << 1);

}



static inline u8 calc_depb(struct held_lock *prev, struct held_lock *next)

{

	return 1U << __calc_dep_bitb(prev, next);

}



/*

 * Forward- or backward-dependency search, used for both circular dependency

 * checking and hardirq-unsafe/softirq-unsafe checking.
@@ -2552,10 +2604,38 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev, 
		if (entry->class == hlock_class(next)) {

			if (distance == 1)

				entry->distance = 1;

			entry->dep |= calc_dep(prev, next);



			/*

			 * Also, update the reverse dependency in @next's

			 * ->locks_before list.

			 *

			 *  Here we reuse @entry as the cursor, which is fine

			 *  because we won't go to the next iteration of the

			 *  outer loop:

			 *

			 *  For normal cases, we return in the inner loop.

			 *

			 *  If we fail to return, we have inconsistency, i.e.

			 *  <prev>::locks_after contains <next> while

			 *  <next>::locks_before doesn't contain <prev>. In

			 *  that case, we return after the inner and indicate

			 *  something is wrong.

			 */

			list_for_each_entry(entry, &hlock_class(next)->locks_before, entry) {

				if (entry->class == hlock_class(prev)) {

					if (distance == 1)

						entry->distance = 1;

					entry->dep |= calc_depb(prev, next);

					return 1;

				}

			}



			/* <prev> is not found in <next>::locks_before */

			return 0;

		}

	}



#ifdef CONFIG_LOCKDEP_SMALL

	/*

	 * Is the <prev> -> <next> link redundant?
@@ -2579,14 +2659,18 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev, 
	 */

	ret = add_lock_to_list(hlock_class(next), hlock_class(prev),

			       &hlock_class(prev)->locks_after,

			       next->acquire_ip, distance, *trace);

			       next->acquire_ip, distance,

			       calc_dep(prev, next),

			       *trace);



	if (!ret)

		return 0;



	ret = add_lock_to_list(hlock_class(prev), hlock_class(next),

			       &hlock_class(next)->locks_before,

			       next->acquire_ip, distance, *trace);

			       next->acquire_ip, distance,

			       calc_depb(prev, next),

			       *trace);

	if (!ret)

		return 0;

CRA Git | Maintained and supported by SUSTech CRA and CCSE