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: Boqun Feng <boqun.feng@gmail.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Link: https://lkml.kernel.org/r/20200807074238.1632519-7-boqun.feng@gmail.com

diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 22750102b5fe2ba3bff41bff23d3127f591d1db3..35c8bb0108dd766b346f1bbcf8c0ed05f97c1dde 100644 (file)
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -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

diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c
index 668a983d6405742017a5d5dbf0bc258da756b964..16ad1b74aa30850f4dba85dbe433c3269bb0c5c9 100644 (file)
--- a/kernel/locking/lockdep.c
+++ b/kernel/locking/lockdep.c
@@ -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,7 +2604,35 @@ check_prev_add(struct task_struct *curr, struct held_lock *prev,
                if (entry->class == hlock_class(next)) {
                        if (distance == 1)
                                entry->distance = 1;
-                       return 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;
                }
        }
 
@@ -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;